@allansantos-dev/smart-tool 0.9.2 → 0.9.4

package/CHANGELOG.md

@@ -1,5 +1,91 @@
 # Changelog
 
+## 0.9.4 - beta
+
+Found by using 0.9.3 on its own repository right after installing it.
+
+- Impact (`graph` with `symbol`), docstring coverage (`docs`), `affected_tests` and the duplicate warning on edit now see
+  every file the index does not reflect yet: working-tree changes, indexed files changed on disk and files committed
+  after the last indexing. In the default `on_search` mode the index only updates on a search, so a function added
+  earlier in the session was "not found" by `graph`, and a copy of it was not flagged by the duplicate warning. Only
+  the current view gets these files; a pinned or older view is read as indexed.
+- The code graph analysis is saved next to the index (`graph-cache/`, about 0.3 MB per view) and reloaded after a
+  daemon restart or when a project left the in-memory cache: 0.03-0.12 s instead of 7-11 s of analysis on remeda
+  and gson. An indexing job warms the graph when it ends. The duplicate warning, which never waits for an analysis,
+  used to skip the first edit after a restart or a reindex; it now checks it.
+- Hook routing decides more Bash commands without the router model: a search verb after a single `|` filters the
+  output of the command before it (`python x.py | tail -5`, `npm test | grep FAIL`) and no longer sends the call to
+  the model, unless that command reads code or pages (`git grep`, `git ls-files`, `curl`, `gh api`, ...). Replayed on
+  2,489 real Bash decisions that went to the model (median 1.5 s, 7.8% redirected): 438 become mechanical, 13 minutes
+  of waiting saved in 58 hours, 1 of 155 redirects lost. Search verbs after `do`/`then`/`else` and inside a quoted
+  `bash -c "..."` / `powershell -Command "..."` are now recognized.
+- `affected_tests` no longer asks for the whole suite when only CI configuration or repository metadata changed
+  (`.github/`, `.gitlab-ci.yml`, `Jenkinsfile`, `.gitignore`, `.gitattributes`, `LICENSE`, ...).
+- The docstring reminder on edit only applies to code files of registered projects: test files (whose test functions
+  normally have no docstring) and files outside any project are left out, as in the `docs` coverage.
+
+## 0.9.3 - beta
+
+- Camoufox download (1.3 GB) on networks that cut long transfers (seen stopping at 500-530 MB on every attempt): it is
+  now fetched in 32 MB Range requests, each on a new connection, resuming from the last byte received after a dropped
+  or stalled connection, and gives up only after 6 attempts in a row without a new byte. camoufox still verifies the
+  sha256 published for the release before extracting. The downloader uses the standard library, which on Windows
+  trusts the system certificate store (including a corporate TLS inspection CA) and honors HTTPS_PROXY.
+- `project_manage graph` with `symbol` (function, `Class.method`, class, or `path::name` when the name repeats): where
+  it is defined, its callers with line, what it calls, the tests that reach it through static calls (`depth` hops,
+  default 3) and the files importing its module, so an agent knows what to update before an edit. With `file_path`, the graph caps its lists by `limit` and drops display-only data.
+- Documentation on edit (setup, Agents): the hook checks the functions a Claude Code Edit/MultiEdit/Write or a Codex
+  apply_patch touches. Remind (default) tells the agent which ones have no docstring and which documented ones changed
+  their signature, with callers; Require blocks an edit that leaves a touched function without a
+  docstring; Off disables it. Body-only edits of documented functions stay silent. The hook matcher now includes the
+  edit tools: reinstall the hook from the setup screen (it shows as outdated).
+- Documentation on edit asks only for public functions: private (`_name`, `#name`, `private`), nested, callback and
+  override (`@Override`, `@override`) functions are exempt, following pydocstyle, eslint-plugin-jsdoc and Checkstyle
+  defaults, and a JSDoc above TypeScript overload signatures documents the implementation. On remeda, gson, express
+  and click the former rule asked for docstrings on every overload implementation, callback and `@Override` method.
+  TypeScript, JavaScript and Java edits were never checked on Windows (the file was looked up by its absolute path in
+  the analyzer output, which normalizes it); they are now.
+- Duplicate functions on edit (setup, Agents; Warn by default, Off): when an edit writes a function whose body is
+  identical (comments, spacing, docstrings ignored) or near-identical (only local names, strings and numbers changed)
+  to an indexed one, the agent is told where the original is so it can reuse it; the edit is never blocked. Measured
+  on click, express, remeda and gson: every exact and locally renamed copy found, no warning when each real function
+  is written as it is.
+- `project_manage action=affected_tests`: tests to run for the uncommitted changes (or against `base`): every test
+  file importing a changed file, directly or transitively, plus changed tests, likeliest failures first (tests calling
+  a touched function, test files named after the function or module, import distance), with the command per runner
+  (pytest, unittest, vitest, jest, mocha, node --test, Maven, Gradle). `run_all` with the reason when configuration,
+  lockfiles or code outside the import graph changed. In fault-injection runs (30 faults each), selection by imports
+  caught every failing test file in express and all but timing-flaky ones in remeda; static calls alone, as the
+  `graph` impact lists them, found 2 to 37%.
+  Changed files are read from the working tree, so a new file or a new import counts before the project is reindexed (in on_search mode the index only updates on a search), and a test that takes a pytest fixture from a
+  conftest.py depends on what that conftest imports (a change in click's `testing.py` selected 4 of the 20 failing
+  test files; now all 20).
+- Near-duplicate detection (`action=duplicates` and the edit hook) keeps keywords, called names, attributes and types
+  and abstracts only local names, strings and numbers, compares functions of the same language only and skips
+  overloads and language idioms: parallel functions such as `get_text_stdin`/`get_text_stdout` or
+  `rotateLeft`/`rotateRight` are no longer reported (near pairs fell from 5-14% of functions to 0-1.6%).
+- Code graph: `require('../')` resolved to a wrong absolute path, and workspace packages imported by name
+  (`import { x } from "my-lib"` in a monorepo) were treated as external; both now resolve to the package source. Vitest
+  type tests (`*.test-d.ts`, `*.spec-d.ts`) are classified as tests. The TypeScript and Java analyzers retry with a
+  4 GB heap when 1 GB is not enough (larger projects ended with no symbols).
+- `web_fetch` on pages over 60,000 characters (14.6% of cached pages, 10.4% of real calls) no longer keeps only the
+  start: the whole page is cached (up to 1,000,000 characters) and the model reads the 2,000-character pieces most
+  similar to the prompt, up to 15,000 characters, in page order. Measured on 18 real pages and 41 questions: answers
+  about text after the old cut 0/28 → 13/28. Pieces are embedded once per page and embedding model (first read of a
+  75-256k page adds 2.6-6.8 s, later questions about 1 s); without a working `embedding_model` such a page fails
+  with the reason instead of being cut silently. Pages up to 60,000 characters are read whole, as before (selection
+  there tied on quality and added latency).
+- Hook metrics: concurrent hook calls from Claude Code and Codex could be logged with each other's client name.
+- Web search health log tells a provider 429 (`rate_limited`), a captcha and a self-imposed quota pause (`paused`, not
+  counted against the provider) apart from an ordinary failure.
+- `project_manage action=docs`: docstring coverage of the indexed code (public functions without a docstring per file,
+  coverage percent; tests only with `include_tests`), for documenting a project that started without them.
+- Impact results (`graph` with `symbol`) carry the first docstring line of the definition, callers, calls and tests.
+- `project_manage` for agents: every action takes `project_root` instead of `project_id`; `list` returns one short line
+  per project (it returned the full jobs, scope and preview of every project, about 1 MB with 14 projects, more than
+  an agent can read; the projects screen still gets the full list); an index job's result is no longer repeated as
+  `stats`.
+
 ## 0.9.2 - beta
 
 - Installer reported success after a broken Camoufox download: camoufox 0.5.6 prints the error of `fetch` and exits 0.

package/README.md

@@ -6,8 +6,8 @@ A local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharpe
 |---|---|
 | `smart_search` / `smart_search_result` | Semantic + lexical search over an indexed project, results split into code, tests and docs, with the likeliest functions per chunk |
 | `web_search` / `web_search_result` | Web search across several sources in parallel, in the query language and in English, with a cache shared across sessions; `depth="research"` runs a multi-round research loop |
-| `web_fetch` | Reads a known URL and returns only the answer to your prompt, written by a small model; pages are cached for 24 h |
-| `project_manage` | Registers and indexes projects, shows coverage, code maps, duplicated functions and index storage |
+| `web_fetch` | Reads a known URL and returns only the answer to your prompt, written by a small model; pages are cached for 24 h. Pages over 60,000 characters are not cut: the model reads the parts closest to the prompt (needs an `embedding_model`) |
+| `project_manage` | Registers and indexes projects, shows coverage, code maps, duplicated functions and index storage; `graph` with `symbol` tells what changing a function touches: callers, calls, the tests that reach it and the files that import it |
 
 An optional hook routes the agent's native Grep/Glob/Read/Bash/WebSearch/WebFetch calls to these tools when they
 are cheaper, or just tells the agent what Smart Tool would do.
@@ -53,6 +53,31 @@ Open the setup screen from the tray icon ("Open settings") or at `http://127.0.0
    - **Redirect** (default): the native tool is denied with the reason and the Smart Tool tool to use.
    - **Advise only**: the native tool runs; the agent receives the same advice next to the result and decides.
    - **Off**: no routing.
+
+   **Documentation on edit** checks the public functions an edit touches (Python docstrings, JSDoc, Javadoc), in
+   Claude Code edits and Codex patches. Private (`_name`, `#name`, `private`), nested and override (`@Override`,
+   `@override`) functions are exempt, as in pydocstyle, eslint-plugin-jsdoc and Checkstyle, and a JSDoc above a set of
+   TypeScript overloads documents the implementation:
+   - **Remind** (default): the edit runs and the agent is told which touched functions have no docstring, and which
+     documented ones changed their signature, with their callers.
+   - **Require**: an edit that leaves a touched function without a docstring is blocked until it adds one.
+   - **Off**: no checks.
+
+   A documented function edited only in its body is not mentioned. `project_manage` with `action=docs` lists the
+   public functions still without a docstring, for documenting a project that started without them.
+
+   **Duplicate functions on edit** compares the functions an edit writes with the indexed code. **Warn** (default)
+   tells the agent when a written function has the same body as an existing one (comments, spacing and docstrings
+   ignored) or a near-identical one (only local names, strings and numbers changed), with the path and lines of the
+   original to reuse; it never blocks. Editing a function in place, overloads, tests, generated files and small
+   functions (under 5 lines or 50 tokens) are not checked. **Off** disables it.
+
+   After editing, `project_manage` with `action=affected_tests` lists the tests to run: every test file that imports a
+   changed file, directly or through other files (git diff against `base`, default `HEAD`, untracked files included),
+   plus changed tests and tests using a pytest fixture whose `conftest.py` imports the changed code, ordered with the
+   likeliest failures first, and the command to run them. Changed files are read from disk, so new files and imports
+   count before the project is reindexed. `run_all` is true, with
+   the reason, when a configuration or lockfile changed or a changed code file is outside the import graph.
 4. **Local models** (optional): if the mcp-memory embedding sidecar is installed on the machine, its local embedder
    can serve as a fallback (or preferred) embedding model.
 5. **Web search providers** work without keys on their free public tiers; add your own key for more volume. Set your

package/affected_tests.py

@@ -0,0 +1,301 @@
+"""Tests to run for the current changes: git diff against a base (default HEAD, so staged, unstaged and untracked
+files), then every test file that imports a changed file directly or through other files, plus changed tests, ordered
+so the most likely failures come first (tests calling a touched function, test file named after the function or the
+module, import distance). Test support files (conftest.py, helpers other tests import) carry the selection but are
+not listed to run. Selection by file imports, not by calls: in fault-injection measurements on Python,
+JavaScript, TypeScript and Java projects static calls alone found 2 to 37% of the failing test files."""
+import ast
+import json
+import os
+import re
+import subprocess
+from collections import defaultdict, deque
+
+import code_graph
+import index_inventory
+import index_profile
+import index_scope
+
+RUN_ALL = re.compile(
+    r"(^|/)(package\.json|package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|pnpm-workspace\.yaml|"
+    r"bun\.lockb?|pyproject\.toml|setup\.cfg|setup\.py|pytest\.ini|tox\.ini|requirements[^/]*\.txt|poetry\.lock|"
+    r"uv\.lock|Pipfile(\.lock)?|tsconfig[^/]*\.json|jsconfig\.json|(jest|vitest|vite|babel)\.config\.[^/]+|"
+    r"\.babelrc|\.mocharc[^/]*|pom\.xml|build\.gradle(\.kts)?|settings\.gradle(\.kts)?|gradle\.properties|"
+    r"\.env[^/]*)$")
+CI_CONFIG = re.compile(r"(^|/)(\.github|\.circleci|\.buildkite)/|(^|/)(\.gitlab-ci\.ya?ml|azure-pipelines\.ya?ml|"
+                       r"Jenkinsfile|\.travis\.ya?ml|bitbucket-pipelines\.ya?ml|\.gitignore|\.gitattributes|"
+                       r"\.editorconfig|\.mailmap|CODEOWNERS|LICENSE(\.[^/]*)?|\.npmignore)$")
+NOTE = ("Selection from the indexed import graph: tests that load code through strings (mock.patch targets, "
+        "importlib, require(variable), reflection, Spring scanning) or read data files are not seen. Run the full "
+        "suite before committing; run_all is true when a changed file can change every test (config, lockfile, "
+        "unanalyzed code). Changed files and files committed after the last indexing are read from disk, so new "
+        "files and imports count before reindexing; pytest fixtures link a test to the conftest.py that defines them.")
+_HUNK = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", re.M)
+
+
+def _git(root, *args):
+    result = subprocess.run(["git", *args], cwd=root, capture_output=True, timeout=60)
+    if result.returncode:
+        raise ValueError(f"git {' '.join(args[:2])} failed: {result.stderr.decode('utf-8', 'replace').strip()[:300]}")
+    return result.stdout.decode("utf-8", "replace")
+
+
+def _changes(root, base):
+    """Project-relative changed paths with their status and the new-side changed lines (None = whole file)."""
+    top = _git(root, "rev-parse", "--show-toplevel").strip()
+    prefix = os.path.relpath(os.path.realpath(root), os.path.realpath(top)).replace(os.sep, "/")
+    prefix = "" if prefix == "." else prefix + "/"
+    _git(root, "rev-parse", "--verify", "--quiet", f"{base}^{{commit}}")
+    changes = {}
+    fields = _git(root, "diff", "--name-status", "-z", "--no-renames", base, "--", ".").split("\0")
+    for status, path in zip(fields[0::2], fields[1::2]):
+        if path.startswith(prefix):
+            changes[path[len(prefix):]] = {"status": "deleted" if status == "D" else "changed", "lines": set()}
+    for path in _git(root, "ls-files", "--others", "--exclude-standard", "-z", "--full-name", "--", ".").split("\0"):
+        if path and path.startswith(prefix):
+            changes[path[len(prefix):]] = {"status": "added", "lines": None}
+    diff = _git(root, "diff", "-U0", "--no-renames", "--relative", base, "--", ".")
+    for block in re.split(r"^diff --git ", diff, flags=re.M)[1:]:
+        target = re.search(r"^\+\+\+ b/(.+)$", block, re.M)
+        if target and target.group(1) in changes and changes[target.group(1)]["lines"] is not None:
+            for start, count in _HUNK.findall(block):
+                first, size = int(start), int(count or 1)
+                changes[target.group(1)]["lines"].update(range(first, first + max(size, 1)))
+    return changes
+
+
+def _depths(start, reverse):
+    seen, frontier = {node: 0 for node in start}, deque(start)
+    while frontier:
+        node = frontier.popleft()
+        for nxt in reverse.get(node, ()):
+            if nxt not in seen:
+                seen[nxt] = seen[node] + 1
+                frontier.append(nxt)
+    return seen
+
+
+def _nearest(root, start, names):
+    folder = os.path.dirname(start)
+    while True:
+        for name in names:
+            if os.path.isfile(os.path.join(root, folder, name)):
+                return folder, name
+        if not folder:
+            return None, None
+        folder = os.path.dirname(folder)
+
+
+def _read(path):
+    try:
+        with open(path, encoding="utf-8") as stream:
+            return stream.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def _commands(root, tests):
+    """One command per runner and folder for the selected test files, or the reason none could be built."""
+    groups = defaultdict(list)
+    for path in tests:
+        lower = path.lower()
+        if lower.endswith(".py"):
+            folder, marker = _nearest(root, path, ("pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"))
+            pytest = (marker and "pytest" in _read(os.path.join(root, folder or "", marker))) \
+                or _nearest(root, path, ("conftest.py",))[1] \
+                or re.search(r"^\s*(import pytest|from pytest import)", _read(os.path.join(root, path)), re.M)
+            test_dir = os.path.dirname(path)
+            if pytest:
+                groups[(folder or "", "python -m pytest")].append(path)
+            elif os.path.isfile(os.path.join(root, test_dir, "__init__.py")):
+                groups[("", "unittest-package")].append(path)
+            else:
+                groups[(test_dir, "unittest-folder")].append(path)
+        elif lower.endswith((".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts")):
+            folder, _name = _nearest(root, path, ("package.json",))
+            try:
+                package = json.loads(_read(os.path.join(root, folder or "", "package.json")) or "{}")
+            except ValueError:
+                package = {}
+            tools = " ".join([str((package.get("scripts") or {}).get("test", ""))]
+                             + list(package.get("devDependencies") or {}) + list(package.get("dependencies") or {}))
+            runner = next((cmd for key, cmd in (("vitest", "npx vitest run"), ("jest", "npx jest"),
+                                                ("mocha", "npx mocha"), ("node --test", "node --test"))
+                           if key in tools), None)
+            groups[(folder or "", runner)].append(path)
+        elif lower.endswith(".java"):
+            folder, name = _nearest(root, path, ("pom.xml", "build.gradle", "build.gradle.kts"))
+            groups[(folder or "", "maven" if name == "pom.xml" else "gradle" if name else None)].append(path)
+        else:
+            groups[("", None)].append(path)
+    commands = []
+    for (folder, runner), files in sorted(groups.items(), key=lambda item: (item[0][0], str(item[0][1]))):
+        local = [os.path.relpath(f, folder or ".").replace(os.sep, "/") for f in files]
+        if runner is None:
+            commands.append({"cwd": folder or ".", "command": None, "files": local,
+                             "reason": "No known test runner configured for these files."})
+            continue
+        if runner == "maven":
+            names = ",".join(sorted({os.path.basename(f).rsplit(".", 1)[0] for f in files}))
+            line = f"mvn test -Dtest={names} -Dsurefire.failIfNoSpecifiedTests=false"
+        elif runner == "unittest-package":
+            line = "python -m unittest " + " ".join(sorted(f[:-3].replace("/", ".") for f in files))
+        elif runner == "unittest-folder":
+            line = "python -m unittest " + " ".join(sorted(os.path.basename(f)[:-3] for f in files))
+        elif runner == "gradle":
+            wrapper = "./gradlew" if os.path.isfile(os.path.join(root, folder, "gradlew")) else "gradle"
+            line = wrapper + " test " + " ".join(f"--tests {os.path.basename(f).rsplit('.', 1)[0]}" for f in sorted(files))
+        else:
+            line = runner + " " + " ".join(sorted(local))
+        commands.append({"cwd": folder or ".", "command": line})
+    return commands
+
+
+def _fixtures(source):
+    """Fixture names a conftest defines and whether one of them is autouse."""
+    names, autouse = set(), False
+    for node in ast.walk(ast.parse(source)):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            for decorator in node.decorator_list:
+                text = ast.unparse(decorator)
+                if "fixture" in text:
+                    names.add(node.name)
+                    autouse |= "autouse=True" in text.replace(" ", "")
+    return names, autouse
+
+
+def _parameters(source):
+    return {arg.arg for node in ast.walk(ast.parse(source)) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            for arg in node.args.posonlyargs + node.args.args + node.args.kwonlyargs}
+
+
+def _fixture_users(root, test_files):
+    """conftest.py -> Python test files (and nested conftests) below it that take one of its fixtures as a parameter,
+    or all of them when it has an autouse fixture: pytest injects fixtures by name, without an import."""
+    users = defaultdict(set)
+    python = [p for p in test_files if p.endswith(".py")]
+    params = {}
+    for conftest in (p for p in python if os.path.basename(p) == "conftest.py"):
+        try:
+            names, autouse = _fixtures(_read(os.path.join(root, conftest)))
+        except SyntaxError:
+            continue
+        folder = os.path.dirname(conftest)
+        for path in python:
+            if path == conftest or folder and not path.startswith(folder + "/"):
+                continue
+            if path not in params:
+                try:
+                    params[path] = _parameters(_read(os.path.join(root, path)))
+                except SyntaxError:
+                    params[path] = set()
+            if autouse or names & params[path]:
+                users[conftest].add(path)
+    return users
+
+
+def affected(root, base="HEAD", limit=30, view_id=None):
+    """Test files to run for the changes since base, most likely failures first, with the command to run them."""
+    if not isinstance(base, str) or not re.fullmatch(r"[\w./@^~{}-]{1,200}", base) or base.startswith("-"):
+        raise ValueError("base must be a git revision such as HEAD, main or origin/main.")
+    changes = _changes(root, base)
+    selected = index_inventory.inspect(root, view_id)["selected"] or {}
+    pending = code_graph.pending_changes(root, selected["path"]) if selected.get("current") else {}
+    data = code_graph.build_overlay(root, {**pending, **{path: change["status"] for path, change in changes.items()}},
+                                    view_id)
+    profile = index_profile.current((index_scope.load_scope(root) or {}).get("profile"))
+    kind = {}
+    for path in set(changes) | {f["path"] for f in data.get("files") or []}:
+        kind[path] = index_profile.kind(path, profile)
+    parsed = {f["path"] for f in data.get("files") or [] if f.get("analysis") == "parsed"}
+    test_files = {f["path"] for f in data.get("files") or [] if kind.get(f["path"]) == "test"}
+    importers, callers = defaultdict(set), defaultdict(set)
+    for dep in data.get("dependencies") or []:
+        if dep.get("target"):
+            importers[dep["target"]].add(dep["source"])
+    for call in data.get("calls") or []:
+        callers[call["target"]].add(call["source"])
+    for conftest, users in _fixture_users(root, test_files).items():
+        importers[conftest] |= users
+    by_id = {s["id"]: s for s in data.get("symbols") or []}
+    run_all, not_analyzed, changed_code, changed_tests, conftests = [], [], [], [], []
+    for path, change in sorted(changes.items()):
+        if CI_CONFIG.search(path):
+            continue
+        if RUN_ALL.search(path):
+            run_all.append(f"{path} changed (configuration or dependencies)")
+        elif os.path.basename(path) == "conftest.py":
+            conftests.append(path)
+        elif kind[path] == "test":
+            changed_tests.append(path)
+        elif kind[path] == "code":
+            changed_code.append(path)
+            if path not in parsed:
+                not_analyzed.append({"path": path, "status": change["status"],
+                                     "reason": "not analyzed (unsupported language, data file or outside the "
+                                               "index scope)"})
+    if not_analyzed:
+        run_all.append(f"{len(not_analyzed)} changed code file(s) outside the import graph; see not_analyzed")
+    touched = [s for s in by_id.values() if s["path"] in changes and s.get("kind") not in ("module", "class", "interface")
+               and (changes[s["path"]]["lines"] is None
+                    or changes[s["path"]]["lines"].intersection(range(s["start_line"], s["end_line"] + 1)))]
+    touched = [s for s in touched if not any(o is not s and o["path"] == s["path"] and o in touched
+                                             and o["start_line"] >= s["start_line"] and o["end_line"] <= s["end_line"]
+                                             for o in touched)] or touched
+    import_depth = {f: d for f, d in _depths([p for p in changed_code if p in parsed], importers).items()
+                    if f in test_files}
+    call_hops = {}
+    for sid, hops in _depths([s["id"] for s in touched], callers).items():
+        symbol = by_id.get(sid)
+        if symbol and symbol["path"] in test_files and hops:
+            call_hops[symbol["path"]] = min(hops, call_hops.get(symbol["path"], hops))
+    names = {s["name"].split("(")[0].split(".")[-1].lower() for s in touched}
+    names = {n for n in names if len(n) > 2 and n not in ("callback", "anonymous", "constructor")}
+    stems = {os.path.basename(p).split(".")[0].lower().lstrip("_") for p in changed_code}
+    selected = {p: "changed" for p in changed_tests}
+    for conftest in conftests:
+        folder = os.path.dirname(conftest)
+        for test in test_files:
+            if not folder or test.startswith(folder + "/"):
+                selected.setdefault(test, f"{conftest} changed")
+    for test in set(import_depth) | set(call_hops):
+        selected.setdefault(test, None)
+    support = {p for p in test_files if os.path.basename(p) == "conftest.py"
+               or any(source in test_files for source in importers.get(p, ()))}
+    selected = {test: reason for test, reason in selected.items() if test not in support}
+
+    def why(test):
+        if selected[test]:
+            return selected[test]
+        if test in call_hops:
+            return f"calls a changed function ({call_hops[test]} hop{'s' if call_hops[test] > 1 else ''})"
+        return f"imports a changed file ({import_depth[test]} step{'s' if import_depth[test] > 1 else ''})"
+
+    def rank(test):
+        base_name = os.path.basename(test).lower()
+        words = set(re.split(r"[^a-z0-9]+", base_name.rsplit(".", 1)[0]))
+        named = 0 if names & words or {n.replace("_", "") for n in names} & words else \
+            1 if any(stem and stem in re.sub(r"[^a-z0-9]", "", base_name) for stem in stems) else 2
+        return (0 if selected[test] == "changed" else 1, call_hops.get(test, 99), named, import_depth.get(test, 99), test)
+
+    ordered = sorted(selected, key=rank)
+    result = {
+        "base": base,
+        "changed": {"code": changed_code[:limit], "tests": changed_tests[:limit],
+                    "other": sorted(p for p in changes if p not in changed_code and p not in changed_tests)[:limit]},
+        "touched_functions": [f"{s['path']}::{s['name']}" for s in touched][:limit],
+        "tests": [{"path": t, "why": why(t)} for t in ordered[:limit]],
+        "counts": {"changed_files": len(changes), "tests": len(ordered), "test_files": len(test_files)},
+        "run_all": bool(run_all),
+        "run_all_reasons": run_all,
+        "not_analyzed": not_analyzed[:limit],
+        "commands": _commands(root, ordered) if ordered else [],
+        "diagnostics": [d.get("reason") for d in data.get("diagnostics") or [] if d.get("reason")],
+        "view": (data.get("selected") or {}).get("label"),
+        "note": NOTE,
+    }
+    if len(ordered) > limit:
+        result["omitted"] = {"tests": len(ordered) - limit}
+    if not changes:
+        result["note"] = "No changes since " + base + ". " + NOTE
+    return result

package/client_hooks.py

@@ -16,9 +16,9 @@ HOME = os.path.expanduser("~")
 PREVIEW_TTL_S = 600
 CLIENTS = {
     "claude": {"label": "Claude Code", "names": {"claude-code"}, "files": [os.path.join(endpoint_sync.claude_dir(), "settings.json")],
-               "docs": "https://code.claude.com/docs/en/hooks", "event": "PreToolUse", "matcher": "Grep|Glob|Read|Bash|WebSearch|WebFetch", "http": True},
+               "docs": "https://code.claude.com/docs/en/hooks", "event": "PreToolUse", "matcher": "Grep|Glob|Read|Bash|WebSearch|WebFetch|Edit|MultiEdit|Write", "http": True},
     "codex": {"label": "Codex", "prefix": "codex", "files": [os.path.join(HOME, ".codex", "hooks.json"), os.path.join(HOME, ".codex", "config.toml")],
-              "docs": "https://learn.chatgpt.com/docs/hooks", "event": "PreToolUse", "matcher": "Bash",
+              "docs": "https://learn.chatgpt.com/docs/hooks", "event": "PreToolUse", "matcher": "Bash|apply_patch",
               "after_install": "Codex only runs new hooks after the user approves the definition in /hooks."},
     "cursor": {"label": "Cursor", "prefix": "cursor", "files": [os.path.join(HOME, ".cursor", "hooks.json")],
                "docs": "https://cursor.com/docs/agent/hooks", "event": "preToolUse", "matcher": "Shell|Read|Grep",