Fix codecov upload to use correct repository slug

Author: wende

.github/workflows/codecov-coverage.yml

@@ -26,3 +26,4 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+          slug: wende/codebook

codebook/CLIENT_SERVER.md

@@ -105,7 +105,7 @@ export CODEBOOK_BASE_URL=http://localhost:3000
 
 See also: [Configuration](CONFIGURATION.md) | [Templates](TEMPLATES.md)
 
-Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
+Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 
 --- BACKLINKS ---
 [TEMPLATES](TEMPLATES.md "codebook:backlink")

codebook/README.md

@@ -55,7 +55,7 @@ codebook run
 
 | Metric    | Value                               |
 | --------- | ----------------------------------- |
-| Version   | [`v0.1.1-2-g73f4032`](codebook:codebook.version)  |
+| Version   | [`v0.1.1-3-g42c6e43`](codebook:codebook.version)  |
 
 ## Documentation Files
 

codebook/TEMPLATES.md

@@ -12,10 +12,10 @@ These templates are resolved **locally by the CLI** - no server required.
 
 **Example:**
 ```markdown
-[`v0.1.1-2-g73f4032`](codebook:codebook.version)
+[`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 ```
 
-**Current version:** [`v0.1.1-2-g73f4032`](codebook:codebook.version)
+**Current version:** [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 
 ## Server Templates
 

codebook/edge-cases/TASK_VERSION_DIFF_SKIPPING.md

@@ -5,8 +5,8 @@
 When creating a task with `codebook task new`, files containing only version changes (like `codebook.version` updates) would create noise in the task output:
 
 ```diff
--Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
-+Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
+-Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
++Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 ```
 
 These diffs provide no useful information for the task.
@@ -33,8 +33,8 @@ A diff is considered "version-only" if:
 --- a/README.md
 +++ b/README.md
 @@ -1,3 +1,3 @@
--Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
-+Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
+-Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
++Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 ```
 
 This file would be **skipped** from the task.
@@ -50,8 +50,8 @@ This file would be **skipped** from the task.
 +## New Section
 +Added new content here.
 +
--Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
-+Rendered by CodeBook [`v0.1.1-2-g73f4032`](codebook:codebook.version)
+-Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
++Rendered by CodeBook [`v0.1.1-3-g42c6e43`](codebook:codebook.version)
 ```
 
 This file would be **included** because it has non-version changes.

src/codebook/cli.py

@@ -1494,6 +1494,66 @@ def _parse_task_frontmatter(content: str) -> dict:
         return {}
 
 
+def _is_binary_file(file_path: Path, git_root: Path) -> bool:
+    """Check if a file is binary using git's detection.
+
+    Args:
+        file_path: Path to the file to check
+        git_root: Path to the git root directory
+
+    Returns:
+        True if the file is binary, False otherwise
+    """
+    try:
+        # Use git diff to detect binary files - it returns "Binary files differ"
+        # for binary files when comparing with empty tree
+        result = subprocess.run(
+            [
+                "git",
+                "diff",
+                "--numstat",
+                "4b825dc642cb6eb9a060e54bf8d69288fbee4904",
+                "--",
+                str(file_path),
+            ],
+            cwd=git_root,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            # Binary files show as "-\t-\t" in numstat output
+            parts = result.stdout.strip().split("\t")
+            if len(parts) >= 2 and parts[0] == "-" and parts[1] == "-":
+                return True
+        return False
+    except Exception:
+        return False
+
+
+def _resolve_sha(sha: str, git_root: Path) -> str | None:
+    """Resolve a SHA (short or full) to its full form.
+
+    Args:
+        sha: The SHA to resolve (can be short or full)
+        git_root: Path to the git root directory
+
+    Returns:
+        Full SHA if resolvable, None otherwise
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", sha],
+            cwd=git_root,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+    except Exception:
+        return None
+
+
 def _is_ancestor_commit(ancestor_sha: str, descendant_sha: str, git_root: Path) -> bool:
     """Check if ancestor_sha is an ancestor of (or equal to) descendant_sha.
 
@@ -1522,14 +1582,18 @@ def _is_ancestor_commit(ancestor_sha: str, descendant_sha: str, git_root: Path)
         return False
 
 
-def _extract_reviewed_files(tasks_dir: Path) -> dict[str, list[tuple[str, str]]]:
+def _extract_reviewed_files(
+    tasks_dir: Path, git_root: Path | None = None
+) -> dict[str, list[tuple[str, str]]]:
     """Extract reviewed file:sha pairs from task frontmatter.
 
     Args:
         tasks_dir: Path to the tasks directory
+        git_root: Path to the git root directory (for resolving short SHAs)
 
     Returns:
         Dict mapping file paths to list of (sha, task_name) tuples
+        SHAs are resolved to full form when git_root is provided.
     """
     reviewed_files: dict[str, list[tuple[str, str]]] = {}
 
@@ -1560,6 +1624,11 @@ def _extract_reviewed_files(tasks_dir: Path) -> dict[str, list[tuple[str, str]]]
                     file_path = file_path.strip()
                     sha = sha.strip()
                     if file_path and sha:
+                        # Resolve short SHA to full SHA if git_root is available
+                        if git_root and len(sha) < 40:
+                            resolved = _resolve_sha(sha, git_root)
+                            if resolved:
+                                sha = resolved
                         if file_path not in reviewed_files:
                             reviewed_files[file_path] = []
                         reviewed_files[file_path].append((sha, task_name))
@@ -1687,8 +1756,8 @@ def extract_commits_from_tasks() -> dict[str, str]:
         click.echo("Extracting commits from task files...")
     task_commits = extract_commits_from_tasks()
 
-    # Extract reviewed files from task frontmatter
-    reviewed_files = _extract_reviewed_files(tasks_dir)
+    # Extract reviewed files from task frontmatter (with short SHA resolution)
+    reviewed_files = _extract_reviewed_files(tasks_dir, git_root)
 
     if not task_commits and not reviewed_files:
         click.echo("No commits found in task files.", err=True)
@@ -1730,11 +1799,23 @@ def extract_commits_from_tasks() -> dict[str, str]:
         if f.exists() and not str(f.resolve()).startswith(str(tasks_dir_resolved))
     ]
 
+    # Filter out binary files (they can't be blamed meaningfully)
+    binary_count = 0
+    text_files = []
+    for f in files_to_analyze:
+        if _is_binary_file(f, git_root):
+            binary_count += 1
+        else:
+            text_files.append(f)
+    files_to_analyze = text_files
+
     if not files_to_analyze:
         click.echo("No files to analyze in scope.", err=True)
         return
 
     if not output_json:
+        if binary_count > 0:
+            click.echo(f"Skipped {binary_count} binary file(s)")
         click.echo(f"Analyzing {len(files_to_analyze)} file(s)...\n")
 
     # Analyze coverage per file

tests/test_cli.py

@@ -1299,6 +1299,103 @@ def test_task_coverage_multiple_reviewed_entries(self, git_repo: Path):
         # Both files should be covered
         assert "100.0%" in result.output or "Overall Coverage:" in result.output
 
+    def test_task_coverage_with_short_sha(self, git_repo: Path):
+        """Should resolve short SHAs in reviewed entries to full SHAs."""
+        runner = CliRunner()
+
+        # Create a source file and commit it
+        src_file = git_repo / "short_sha_code.py"
+        src_file.write_text("def short_sha():\n    return True\n")
+        subprocess.run(["git", "add", "short_sha_code.py"], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add short sha code"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        # Get the full commit SHA and extract a short version
+        result_sha = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=git_repo,
+            capture_output=True,
+            text=True,
+        )
+        full_sha = result_sha.stdout.strip()
+        short_sha = full_sha[:7]  # Use 7-char short SHA
+
+        # Create a task file with short SHA in reviewed frontmatter
+        tasks_dir = git_repo / "tasks"
+        tasks_dir.mkdir(parents=True)
+        task_file = tasks_dir / "202412281530-SHORT_SHA_TASK.md"
+        task_content = f"""---
+reviewed:
+  - short_sha_code.py:{short_sha}
+---
+# Short SHA Task
+
+This task uses a short SHA for reviewed entry.
+"""
+        task_file.write_text(task_content)
+
+        # Commit the task file
+        subprocess.run(["git", "add", str(task_file)], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add short sha task"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        # Run coverage
+        result = runner.invoke(main, ["task", "coverage", str(git_repo)])
+
+        assert result.exit_code == 0
+        assert "reviewed file(s)" in result.output
+        assert "short_sha_code.py" in result.output
+        # The file should show as covered (short SHA was resolved)
+        assert "100.0%" in result.output or "✓" in result.output
+
+    def test_task_coverage_skips_binary_files(self, git_repo: Path):
+        """Should skip binary files in coverage analysis."""
+        runner = CliRunner()
+
+        # Create a text source file
+        src_file = git_repo / "text_code.py"
+        src_file.write_text("def text():\n    return True\n")
+
+        # Create a binary file (PNG header bytes)
+        binary_file = git_repo / "image.png"
+        binary_file.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00")
+
+        subprocess.run(["git", "add", "."], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add text and binary files"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        # Create a minimal task file to enable coverage
+        tasks_dir = git_repo / "tasks"
+        tasks_dir.mkdir(parents=True)
+        task_file = tasks_dir / "202412281530-BINARY_TEST.md"
+        task_file.write_text("# Binary Test\n\nTest binary file skipping.\n")
+        subprocess.run(["git", "add", str(task_file)], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add binary test task"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        # Run coverage
+        result = runner.invoke(main, ["task", "coverage", str(git_repo)])
+
+        assert result.exit_code == 0
+        # Should mention skipping binary files
+        assert "Skipped" in result.output and "binary" in result.output
+        # Should analyze text file
+        assert "text_code.py" in result.output
+        # Should NOT analyze binary file
+        assert "image.png" not in result.output or "Could not analyze" not in result.output
+
     def test_task_mark_reviewed_help(self, runner: CliRunner):
         """Should show mark-reviewed help."""
         result = runner.invoke(main, ["task", "mark-reviewed", "--help"])