codigest 0.6.0__tar.gz → 0.7.0__tar.gz

{codigest-0.6.0 → codigest-0.7.0}/CITATION.cff

@@ -14,7 +14,7 @@ authors:
 repository-code: "https://github.com/NaNIsaac/codigest"
 url: "https://pypi.org/project/codigest/"
 license: MIT
-version: 0.6.0
+version: 0.7.0
 date-released: "2026-10-17"
 keywords:
   - LLM

{codigest-0.6.0 → codigest-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codigest
-Version: 0.6.0
+Version: 0.7.0
 Summary: Human-Centered Codebase Context Manager for LLMs
 Project-URL: Homepage, https://github.com/NaNIsaac/codigest
 Project-URL: Repository, https://github.com/NaNIsaac/codigest
@@ -180,13 +180,16 @@ When a file you expected is missing, or one you didn't expect is there, this is
 fills its token budget (default 30,000):
 
 1. Files you name: `cdg pack src/prices.py`.
-2. Files named in the output of the last failed command run in this project:
-   `File "x.py", line 7` (Python), `x.py:7` (pytest, gcc, rustc, eslint), `x.ts(7,3)` (tsc).
-   Once the same command passes again, that failure is no longer used.
+2. Files named in the output of the last failed command run in this project in the past hour:
+   `File "x.py", line 7` (Python), `x.py:7` (pytest, ruff, gcc, rustc, eslint), `x.ts(7,3)` (tsc).
+   Once the same command passes again, that failure is no longer used. A file that is only named
+   in the output, not changed by you, comes as an excerpt: ten lines around each place the output
+   points at, marked with a `lines="40-60"` attribute. Short files come whole.
 3. Files you changed: uncommitted and untracked files in Git, or changes since `cdg mark` if you
    set a baseline (see [below](#see-what-changed-since-a-point)).
-4. Tests that import a changed Python file (`test_*.py`, `*_test.py`).
-5. Local Python modules imported by the files above.
+4. Tests that import a changed file (`test_*.py`, `*_test.py`, `*.test.ts`, `*.spec.js`, ...).
+5. Project files imported by the files from steps 1, 3 and 4: Python imports, and relative imports in
+   JS/TS (`./x`, `./x.js` for `x.ts`, `./dir` for `dir/index.ts`).
 
 The failed command and the diff are always included. `.env`, `*.pem`, `*.key` and SSH keys never
 are. Tokens are estimated at four characters each, so the budget is approximate.

{codigest-0.6.0 → codigest-0.7.0}/README.ko.md

@@ -150,13 +150,16 @@ claude mcp add --scope user codigest -- cdg mcp      # Claude Code
 예산(기본 30,000)을 채웁니다.
 
 1. 직접 지정한 파일: `cdg pack src/prices.py`
-2. 이 프로젝트에서 마지막으로 실패한 명령의 출력에 나온 파일:
-   `File "x.py", line 7`(Python), `x.py:7`(pytest, gcc, rustc, eslint), `x.ts(7,3)`(tsc).
-   같은 명령이 다시 통과하면 그 실패는 더 이상 쓰지 않습니다.
+2. 이 프로젝트에서 최근 한 시간 안에 마지막으로 실패한 명령의 출력에 나온 파일:
+   `File "x.py", line 7`(Python), `x.py:7`(pytest, ruff, gcc, rustc, eslint), `x.ts(7,3)`(tsc).
+   같은 명령이 다시 통과하면 그 실패는 더 이상 쓰지 않습니다. 내가 바꾸지 않고 출력에만 나온
+   파일은 발췌로 들어갑니다. 출력이 가리킨 곳마다 앞뒤 열 줄이며 `lines="40-60"` 속성이
+   붙습니다. 짧은 파일은 통째로 들어갑니다.
 3. 바꾼 파일: Git의 커밋 안 된 파일과 추적 안 된 파일. `cdg mark`로 기준점을 잡았다면 그
    이후의 변경([아래](#어느-시점-이후-바뀐-것-보기) 참고).
-4. 바뀐 Python 파일을 import하는 테스트(`test_*.py`, `*_test.py`).
-5. 위 파일들이 import하는 프로젝트 내 Python 모듈.
+4. 바뀐 파일을 import하는 테스트(`test_*.py`, `*_test.py`, `*.test.ts`, `*.spec.js` 등).
+5. 1·3·4단계 파일이 import하는 프로젝트 파일: Python import와 JS/TS 상대 경로 import
+   (`./x`, `x.ts`를 가리키는 `./x.js`, `dir/index.ts`를 가리키는 `./dir`).
 
 실패한 명령과 diff는 항상 들어가고, `.env`, `*.pem`, `*.key`, SSH 키는 절대 들어가지 않습니다.
 토큰은 네 글자를 하나로 어림하므로 예산은 대략적인 값입니다.

{codigest-0.6.0 → codigest-0.7.0}/README.md

@@ -154,13 +154,16 @@ When a file you expected is missing, or one you didn't expect is there, this is
 fills its token budget (default 30,000):
 
 1. Files you name: `cdg pack src/prices.py`.
-2. Files named in the output of the last failed command run in this project:
-   `File "x.py", line 7` (Python), `x.py:7` (pytest, gcc, rustc, eslint), `x.ts(7,3)` (tsc).
-   Once the same command passes again, that failure is no longer used.
+2. Files named in the output of the last failed command run in this project in the past hour:
+   `File "x.py", line 7` (Python), `x.py:7` (pytest, ruff, gcc, rustc, eslint), `x.ts(7,3)` (tsc).
+   Once the same command passes again, that failure is no longer used. A file that is only named
+   in the output, not changed by you, comes as an excerpt: ten lines around each place the output
+   points at, marked with a `lines="40-60"` attribute. Short files come whole.
 3. Files you changed: uncommitted and untracked files in Git, or changes since `cdg mark` if you
    set a baseline (see [below](#see-what-changed-since-a-point)).
-4. Tests that import a changed Python file (`test_*.py`, `*_test.py`).
-5. Local Python modules imported by the files above.
+4. Tests that import a changed file (`test_*.py`, `*_test.py`, `*.test.ts`, `*.spec.js`, ...).
+5. Project files imported by the files from steps 1, 3 and 4: Python imports, and relative imports in
+   JS/TS (`./x`, `./x.js` for `x.ts`, `./dir` for `dir/index.ts`).
 
 The failed command and the diff are always included. `.env`, `*.pem`, `*.key` and SSH keys never
 are. Tokens are estimated at four characters each, so the budget is approximate.

codigest-0.7.0/docs/dogfood.md

@@ -0,0 +1,64 @@
+# Using Codigest on itself
+
+Notes from running `cdg` on real work in this repository and a few sibling projects, on Windows
+(PowerShell and Git Bash). Each entry says what happened, what was wrong, and what changed.
+
+## Lint errors across a whole package
+
+`cdg cap -- uvx ruff check src`, then `cdg pack`.
+
+- **Before:** ruff named 32 files. `pack` added 22 of them whole and dropped 10 for budget:
+  about 30k tokens, most of it code far from any error.
+- **Change:** a file that the output only points at, and that you did not change, now comes as
+  an excerpt: ten lines around each reference, with a `lines="..."` attribute. All 33 files fit
+  in about 26k tokens, each with the context around its errors.
+- **Change:** the summary line now says `4 places in failing output (excerpt)` instead of
+  listing every line number, which wrapped at 80 columns.
+
+## A traceback into a large module
+
+A real `AttributeError` raised at line 255 of the 286-line `core/termstore.py`.
+
+- The pack was about 1.6k tokens: the traceback, and lines 245 to 265 of `termstore.py`. The
+  failing line and the loop around it were in the excerpt.
+- **Bug:** the command `render([object()])` showed as `render()` in the summary; the terminal
+  library read `[object()]` as a style tag. Commands and paths are now escaped, in `cdg term` too.
+- **Change:** the excerpted file's imports (`redact.py`, `tags.py`) were added whole and were not
+  relevant. Imports are now followed only from files you named, changed, or tests of those.
+
+## A passing run after an old failure
+
+Tests passed, but `pack` still used a ruff failure from minutes earlier and filled the budget with
+lint files.
+
+- With the shell hook, every `ls` and `git status` is captured, so "the last command passed"
+  cannot mean "nothing is failing". Failures older than an hour are now ignored.
+- A failure from a few minutes ago is still used. The summary names it and its age on the first
+  line, so it is visible, but this case stays a judgment call.
+
+## `cdg cap -- npm test` on Windows
+
+- **Bug:** `Command not found: npm`. npm on Windows is `npm.cmd`, which the process API does not
+  find without the extension. Relative paths with forward slashes (`.venv/Scripts/python`) failed
+  the same way from Git Bash. The program is now resolved the way a shell resolves it.
+- **Bug:** npm's exit code `-4058` was stored as `4294963238`. Exit codes are now shown signed.
+
+## Other projects
+
+`cdg cap -- uv run --with pytest pytest -q` in deai, hanfix, QoraPhase and QoraGeom.
+
+- Passing suites with a clean tree: `pack` says there is nothing to pack and what to run. Correct.
+- hanfix exited 5 (pytest collected no tests); the pack was the 64-token output and nothing else.
+  Correct, if not very useful.
+
+## Where it helps, and where it doesn't
+
+- **Pasting into a chat model.** The clearest win. One command replaces copying the error, the
+  test and the changed file, and the `reason` on each file plus the `<omitted>` list tell the
+  model what it has and lacks.
+- **An agent that can read files itself** (Claude Code, Codex). The file contents save a few tool
+  calls but are not essential. What the agent cannot get otherwise is the output of commands the
+  person ran in their own terminal; that is the part of `pack` and `terminal_history` that matters
+  here. When the agent runs the command itself, it already has the output.
+- **Token counts** are estimates (four characters per token). They were within the budget in
+  every run above, but they are not exact.

{codigest-0.6.0 → codigest-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codigest"
-version = "0.6.0"
+version = "0.7.0"
 description = "Human-Centered Codebase Context Manager for LLMs"
 authors = [{ name = "Isaac Yong", email = "isaacyong@naver.com" }]
 readme = "README.md"

{codigest-0.6.0 → codigest-0.7.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/NaNIsaac/codigest",
     "source": "github"
   },
-  "version": "0.6.0",
+  "version": "0.7.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "codigest",
-      "version": "0.6.0",
+      "version": "0.7.0",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"

{codigest-0.6.0 → codigest-0.7.0}/src/codigest/commands/pack.py

@@ -6,10 +6,11 @@ in that order until the token budget runs out; whatever is left out is listed,
 so the reader knows what it is not seeing.
 """
 import re
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 import typer
+from rich.markup import escape
 
 from ..options import CopyOption, MessageOption, StdoutOption
 
@@ -18,19 +19,33 @@ lazy from ..core import common, git_ops, processor, resolver, shadow, tags, term
 lazy from ..core.output import OutputHandler
 
 DEFAULT_BUDGET = 30_000
+# A file that is only named in the failing output gets this many lines around each reference.
+EXCERPT_CONTEXT = 10
+EXCERPT_MIN_LINES = 60
+FAILURE_MAX_AGE = timedelta(hours=1)
 
 # `File "x.py", line 7` (Python) or `x.py:7` / `x.ts(7,3)` (pytest, tsc, gcc, rustc, eslint, ...)
 _LOCATION_RE = re.compile(r'File "(?P<py>[^"]+)", line (?P<py_line>\d+)|(?P<path>[\w./\\~-]+\.\w+)[:(](?P<line>\d+)')
 
-_TEST_FILE_RE = re.compile(r"^test_.*\.py$|^.*_test\.py$")
+_TEST_FILE_RE = re.compile(r"^test_.*\.py$|^.*_test\.py$|\.(test|spec)\.[cm]?[jt]sx?$")
 
-_SECRET_FILE_RE =re.compile(r"^\.env(\..+)?$|\.(pem|key|p12|pfx)$|^id_(rsa|dsa|ecdsa|ed25519)$")
+_JS_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
+# Relative specifiers only: `from './x'`, `import './x'`, `require('./x')`, `import('./x')`.
+_JS_IMPORT_RE = re.compile(r"""(?:\bfrom|\bimport|\brequire\(|\bimport\()\s*['"](\.{1,2}/[^'"]+)['"]""")
+
+_SECRET_FILE_RE = re.compile(r"^\.env(\..+)?$|\.(pem|key|p12|pfx)$|^id_(rsa|dsa|ecdsa|ed25519)$")
 
 
 def pick_failure(entries: list[termstore.Entry], root: Path) -> termstore.Entry | None:
-    """Latest failed command run under `root`, unless the same command has passed since."""
+    """
+    Latest failed command run under `root` within the last hour, unless the same command has
+    passed since. Older failures are rarely what someone running `pack` is looking at.
+    """
+    cutoff = datetime.now().astimezone() - FAILURE_MAX_AGE
     passed: set[str] = set()
     for entry in reversed(termstore.select(entries, under=root)):
+        if _started(entry) < cutoff:
+            return None
         if entry.exit_code == 0:
             passed.add(entry.command)
         elif entry.exit_code is not None and entry.command not in passed:
@@ -38,14 +53,66 @@ def pick_failure(entries: list[termstore.Entry], root: Path) -> termstore.Entry
     return None
 
 
-def referenced_files(output: str, bases: list[Path], known: set[Path]) -> dict[Path, int]:
-    """Project files named in command output, with the first line number given for each."""
-    found: dict[Path, int] = {}
+def _started(entry: termstore.Entry) -> datetime:
+    try:
+        return datetime.fromisoformat(entry.started_at)
+    except ValueError:
+        return datetime.min.replace(tzinfo=timezone.utc)
+
+
+def referenced_files(output: str, bases: list[Path], known: set[Path]) -> dict[Path, list[int]]:
+    """Project files named in command output, with the line numbers given for each, in order."""
+    found: dict[Path, list[int]] = {}
     for m in _LOCATION_RE.finditer(output):
         raw = Path(m["py"] or m["path"]).expanduser()
         for base in bases:
             if (path := (base / raw).resolve()) in known:
-                found.setdefault(path, int(m["py_line"] or m["line"]))
+                if (line := int(m["py_line"] or m["line"])) not in (lines := found.setdefault(path, [])):
+                    lines.append(line)
+                break
+    return found
+
+
+def excerpt(path: Path, lines: list[int]) -> tuple[str, str] | None:
+    """
+    The lines around each reference, numbered, with `...` between gaps, plus the ranges shown
+    ("3-23,40-60"). None when the file is short or the excerpt would be most of it anyway.
+    """
+    try:
+        rows = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return None
+    spans: list[list[int]] = []
+    for line in sorted(lines):
+        lo, hi = max(1, line - EXCERPT_CONTEXT), min(len(rows), line + EXCERPT_CONTEXT)
+        if spans and lo <= spans[-1][1] + 1:
+            spans[-1][1] = max(spans[-1][1], hi)
+        else:
+            spans.append([lo, hi])
+    if len(rows) <= EXCERPT_MIN_LINES or sum(hi - lo + 1 for lo, hi in spans) > len(rows) * 0.7:
+        return None
+    width = len(str(len(rows)))
+    text = "\n...\n".join(
+        "\n".join(f"{i:>{width}}: {rows[i - 1]}" for i in range(lo, hi + 1)) for lo, hi in spans
+    )
+    return text, ",".join(f"{lo}-{hi}" for lo, hi in spans)
+
+
+def js_imports(path: Path) -> set[Path]:
+    """Files a JS/TS module imports by relative path, resolved the way bundlers and tsc do."""
+    try:
+        source = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return set()
+    found = set()
+    for spec in _JS_IMPORT_RE.findall(source):
+        base = (path.parent / spec).resolve()
+        # TS ESM code imports `./x.js` for a file that is `x.ts` on disk.
+        stem = base.with_suffix("") if base.suffix in _JS_SUFFIXES else base
+        for candidate in (base, *(stem.with_name(stem.name + s) for s in _JS_SUFFIXES),
+                          *(base / f"index{s}" for s in _JS_SUFFIXES)):
+            if candidate.is_file():
+                found.add(candidate)
                 break
     return found
 
@@ -112,25 +179,34 @@ def handle(
     for path in ctx.get_target_files(targets=targets) if targets else []:
         wanted.setdefault(path, "requested")
 
+    refs: dict[Path, list[int]] = {}
     failure = pick_failure(termstore.load_entries(), root)
     if failure:
         bases = [Path(failure.cwd), root] if failure.cwd else [root]
-        for path, line in referenced_files(failure.output, bases, known).items():
-            wanted.setdefault(path, f"line {line} in failing output")
+        refs = referenced_files(failure.output, bases, known)
+        for path, lines in refs.items():
+            shown = ", ".join(map(str, lines[:3])) + (", ..." if len(lines) > 3 else "")
+            wanted.setdefault(path, f"line{'s' * (len(lines) > 1)} {shown} in failing output")
 
     diff, diff_source, changed = _changes(root, sorted(known))
+    changed = [p.resolve() for p in changed if p.resolve() in known]
     for path in changed:
-        if path.resolve() in known:
-            wanted.setdefault(path.resolve(), "changed")
+        wanted.setdefault(path, "changed")
 
     deps = resolver.DependencyResolver(root)
-    edited = {p for p, why in wanted.items() if why == "changed" and p.suffix == ".py"}
-    for test in sorted(p for p in known if _TEST_FILE_RE.match(p.name)) if edited else []:
-        if hit := sorted(deps.get_imports(test) & edited):
+
+    def imports(path: Path) -> set[Path]:
+        if path.suffix == ".py":
+            return deps.get_imports(path) & known
+        return js_imports(path) & known if path.suffix in _JS_SUFFIXES else set()
+
+    edited = {p for p, why in wanted.items() if why == "changed"}
+    for test in sorted(p for p in known if _TEST_FILE_RE.search(p.name)) if edited else []:
+        if hit := sorted(imports(test) & edited):
             wanted.setdefault(test, f"tests {hit[0].relative_to(root).as_posix()}")
 
-    for path in [p for p in wanted if p.suffix == ".py"]:
-        for dep in sorted(deps.get_imports(path) & known):
+    for path in [p for p, why in wanted.items() if not why.endswith("failing output")]:
+        for dep in sorted(imports(path)):
             wanted.setdefault(dep, f"imported by {path.relative_to(root).as_posix()}")
 
     if not (failure or diff.strip() or wanted):
@@ -155,15 +231,19 @@ def handle(
         if _SECRET_FILE_RE.search(path.name):
             omitted.append((rel, "may contain secrets"))
             continue
-        content = tags.escape_xml_value(processor.read_file_content(path, add_line_numbers=True))
-        block = f'<file path="{html.escape(rel)}" reason="{html.escape(reason)}">\n{content}\n</file>'
+        # Files you changed or asked for come whole; files the output only points at come as excerpts.
+        part = excerpt(path, refs[path]) if path in refs and reason.endswith("failing output") and path not in changed else None
+        content, shown = part or (processor.read_file_content(path, add_line_numbers=True), "")
+        lines_attr = f' lines="{shown}"' if shown else ""
+        block = f'<file path="{html.escape(rel)}" reason="{html.escape(reason)}"{lines_attr}>\n{tags.escape_xml_value(content)}\n</file>'
         cost = tokenizer.estimate_tokens(block)
         if used + cost > budget:
             omitted.append((rel, f"over budget (~{cost:,} tokens)"))
             continue
         used += cost
         blocks.append(block)
-        included.append((rel, reason))
+        brief = f"{len(refs[path])} places in failing output" if reason.startswith("lines ") else reason
+        included.append((rel, f"{brief} (excerpt)" if shown else brief))
 
     if omitted:
         listing = "\n".join(f"{rel}: {why}" for rel, why in omitted)
@@ -175,13 +255,13 @@ def handle(
     log.print(f"[bold]Packed ~{used:,} / {budget:,} tokens[/bold]{over}")
     if failure:
         when = _ago(failure.started_at)
-        log.print(f"  [red]failed [/red]  [cyan]{failure.command}[/cyan] [dim](exit {failure.exit_code}{', ' + when if when else ''})[/dim]")
+        log.print(f"  [red]failed [/red]  [cyan]{escape(failure.command)}[/cyan] [dim](exit {failure.exit_code}{', ' + when if when else ''})[/dim]")
     if diff.strip():
         log.print(f"  [yellow]changes[/yellow]  [dim]{diff_source}[/dim]")
     width = max((len(rel) for rel, _ in included + omitted), default=0)
     for rel, why in included:
-        log.print(f"  [green]+[/green] {rel:<{width}}  [dim]{why}[/dim]")
+        log.print(f"  [green]+[/green] {escape(rel):<{width}}  [dim]{escape(why)}[/dim]")
     for rel, why in omitted:
-        log.print(f"  [dim]- {rel:<{width}}  {why}[/dim]")
+        log.print(f"  [dim]- {escape(rel):<{width}}  {escape(why)}[/dim]")
 
     handler.handle_output(pack, item_name="pack")

{codigest-0.6.0 → codigest-0.7.0}/src/codigest/commands/term.py

@@ -10,6 +10,7 @@ from typing import Annotated
 
 import typer
 from rich.console import Console
+from rich.markup import escape
 
 from ..options import CopyOption, StdoutOption
 
@@ -65,7 +66,7 @@ def _summarize(handler: OutputHandler, entries: list[termstore.Entry]) -> None:
             case 0: status = " [green]✓[/green]"
             case code: status = f" [red](exit {code})[/red]"
         marker = "" if entry.captured else " [yellow](no output)[/yellow]"
-        log.print(f"[dim]{index}.[/dim] [cyan]{entry.command}[/cyan]{status}{marker}")
+        log.print(f"[dim]{index}.[/dim] [cyan]{escape(entry.command)}[/cyan]{status}{marker}")
 
 
 @app.callback(invoke_without_command=True)

{codigest-0.6.0 → codigest-0.7.0}/src/codigest/core/runner.py

@@ -67,6 +67,10 @@ def resolve_shell() -> list[str] | None:
 def build_argv(args: list[str]) -> list[str]:
     """Maps user-supplied arguments onto an argv for subprocess."""
     if not needs_shell(args):
+        # CreateProcess finds neither `.cmd` shims (npm, yarn, pnpm) nor relative paths written
+        # with forward slashes; which() resolves both the way the user's shell would.
+        if sys.platform == "win32" and (found := shutil.which(args[0])):
+            return [found, *args[1:]]
         return args
     if not (prefix := resolve_shell()):
         return args
@@ -131,6 +135,9 @@ def run(args: list[str]) -> tuple[int, str, int]:
         if process.stdout is not None:
             process.stdout.close()
 
+    # Windows reports exit codes as unsigned 32-bit; shells show them signed (-4058, not 4294963238).
+    if sys.platform == "win32" and exit_code >= 2**31:
+        exit_code -= 2**32
     duration_ms = int((time.monotonic() - started) * 1000)
     output = b"".join(chunks).decode("utf-8", errors="replace")
     return exit_code, output, duration_ms

{codigest-0.6.0 → codigest-0.7.0}/tests/test_pack.py

@@ -4,21 +4,28 @@ from codigest.core.termstore import Entry
 
 
 def test_failure_is_dropped_once_the_same_command_passes(tmp_path):
+    from datetime import datetime, timedelta
+
+    def at(minutes_ago):
+        return (datetime.now().astimezone() - timedelta(minutes=minutes_ago)).isoformat()
+
     cwd = str(tmp_path)
-    fail = Entry(command="pytest", exit_code=1, cwd=cwd, started_at="1")
-    other = Entry(command="mypy .", exit_code=2, cwd=cwd, started_at="0")
-    passed = Entry(command="pytest", exit_code=0, cwd=cwd, started_at="2")
-    elsewhere = Entry(command="make", exit_code=1, cwd=str(tmp_path.parent), started_at="3")
+    other = Entry(command="mypy .", exit_code=2, cwd=cwd, started_at=at(4))
+    fail = Entry(command="pytest", exit_code=1, cwd=cwd, started_at=at(3))
+    passed = Entry(command="pytest", exit_code=0, cwd=cwd, started_at=at(2))
+    elsewhere = Entry(command="make", exit_code=1, cwd=str(tmp_path.parent), started_at=at(1))
 
     assert pack.pick_failure([other, fail], tmp_path) is fail
     assert pack.pick_failure([other, fail, passed, elsewhere], tmp_path) is other
+    stale = Entry(command="ruff check", exit_code=1, cwd=cwd, started_at=at(90))
+    assert pack.pick_failure([stale], tmp_path) is None
 
 
 def test_referenced_files_reads_python_and_compiler_locations(tmp_path):
     a, b = tmp_path / "a.py", tmp_path / "src" / "b.ts"
     output = f'File "{a}", line 7, in f\nsrc/b.ts(3,5): error\n/usr/lib/python3/os.py:12: nope'
     found = pack.referenced_files(output, [tmp_path], {a, b})
-    assert found == {a: 7, b: 3}
+    assert found == {a: [7], b: [3]}
 
 
 def test_changed_paths_skips_deleted_files(tmp_path):
@@ -50,3 +57,31 @@ def test_pack_adds_the_test_that_imports_a_changed_module(tmp_path, monkeypatch)
     out = CliRunner().invoke(app, ["pack", "-s", "--no-copy"]).output
     assert 'path="tests/test_prices.py" reason="tests shop/prices.py"' in out
     assert "test_other.py" not in out
+
+
+def test_js_imports_resolve_like_tsc(tmp_path):
+    (tmp_path / "lib").mkdir()
+    for name in ("price.ts", "lib/index.ts", "old.cjs", "app.service.ts"):
+        (tmp_path / name).write_text("")
+    main = tmp_path / "main.ts"
+    main.write_text(
+        "import { a } from './price.js'\n"
+        "export * from \"./lib\"\n"
+        "const o = require('./old.cjs')\n"
+        "import './app.service'\n"
+        "import React from 'react'\n"
+    )
+    found = {p.relative_to(tmp_path).as_posix() for p in pack.js_imports(main)}
+    assert found == {"price.ts", "lib/index.ts", "old.cjs", "app.service.ts"}
+
+
+def test_excerpt_merges_nearby_references_and_skips_short_files(tmp_path):
+    long = tmp_path / "long.py"
+    long.write_text("".join(f"x{i} = {i}\n" for i in range(1, 201)))
+    text, shown = pack.excerpt(long, [50, 55, 150])
+    assert shown == "40-65,140-160"
+    assert text.splitlines()[0] == " 40: x40 = 40" and "\n...\n" in text
+
+    short = tmp_path / "short.py"
+    short.write_text("a = 1\n" * 30)
+    assert pack.excerpt(short, [3]) is None

{codigest-0.6.0 → codigest-0.7.0}/tests/test_termstore.py

@@ -63,3 +63,17 @@ def test_mcp_refuses_paths_outside_the_project(tmp_path, monkeypatch):
         result = mcp._call_tool("tree", {"path": path})
         assert result["isError"] and "outside the project" in result["content"][0]["text"]
     assert mcp._in_project(".") == str((tmp_path / "proj").resolve())
+
+
+def test_cap_resolves_cmd_shims_and_relative_paths_on_windows(tmp_path, monkeypatch):
+    import sys
+
+    import pytest
+
+    from codigest.core import runner
+    if sys.platform != "win32":
+        pytest.skip("CreateProcess lookup rules are Windows-only")
+    (tmp_path / "tool.cmd").write_text("@echo off\r\nexit /b 3\r\n")
+    monkeypatch.setenv("PATH", str(tmp_path))
+    assert runner.build_argv(["tool", "-x"])[0].lower() == str(tmp_path / "tool.cmd").lower()
+    assert runner.run(["tool"])[0] == 3

{codigest-0.6.0 → codigest-0.7.0}/uv.lock

@@ -16,7 +16,7 @@ wheels = [
 
 [[package]]
 name = "codigest"
-version = "0.6.0"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },