@allansantos-dev/smart-tool 0.9.1 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,82 @@
 # Changelog
 
+## 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.
+  The installer now catches that error and fails the step (retried 3 times), every request of the download has a
+  60 s read timeout (a stalled download used to wait until the 3-minute idle limit), and the final check requires the
+  Camoufox and Chromium executables on disk, so an incomplete browser can never end in "Smart Tool ready".
+- Setup screen: text, model and adapter fields were unstyled boxes (inputs without a type), selects and model fields
+  now look like comboboxes; the hook change opens inside the client's card in a scrollable block with Confirm and
+  Cancel instead of overflowing the page; "Save behavior" works without registering the MCP first; web search keys
+  are set one provider at a time from a provider selector instead of a stack of key fields.
+- Product page: the display font was a family that Google Fonts does not serve (titles fell back to Arial Narrow);
+  it now uses Big Shoulders Display. The page shows the current version (a test keeps it in sync with version.py),
+  links to the release notes and says what the installer does on failures and older installations. A failed Pages
+  deploy is retried once, the run fails unless the live page shows the version, and every release republishes it.
+
 ## 0.9.1 - beta
 
 - Installer on a regular Windows code page (cp1252): the steps' output was garbled or crashed the step; every child

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,292 @@
+"""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_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[^/]*)$")
+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 are read from the working tree, 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)
+    data = code_graph.build_overlay(root, {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 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",

package/code_graph.py

@@ -20,6 +20,8 @@ import web_document_graph
 import document_text
 
 VERSION = 2
+SOURCE_EXTENSIONS = ('.py','.java','.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts','.json','.html','.htm','.css','.scss','.sass','.less','.md','.markdown')
+MAX_OVERLAY_BYTES = 1024 * 1024
 MAX_FILES = 3000
 MAX_TEXT = 24 * 1024 * 1024
 MAX_SYMBOLS = 8000
@@ -72,7 +74,7 @@ def _snapshot(path):
                       'chunks':chunks,'lines':line_count or 0,'group':posixpath.dirname(file_path) or '(root)',
                       'location_kind':document_text.location_kind(file_path),'format':posixpath.splitext(file_path)[1].lower().lstrip('.') or 'text'}
             files.append(record)
-            if not file_path.lower().endswith(('.py','.java','.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts','.json','.html','.htm','.css','.scss','.sass','.less','.md','.markdown')):
+            if not file_path.lower().endswith(SOURCE_EXTENSIONS):
                 continue
             rows = conn.execute('SELECT start_line,end_line,text FROM chunks WHERE path=? ORDER BY start_line,id', (original,)).fetchall()
             text, error = reconstruct(rows)
@@ -228,19 +230,34 @@ def _python_graph(sources):
             'diagnostics':diagnostics,'parsed':list(trees),'truncated':len(symbols)>=MAX_SYMBOLS or len(dependencies)>MAX_EDGES}
 
 
+NODE_HEAP_MB = (1024, 4096)
+
+
+def _run_analyzer(script, payload, failure):
+    """Runs a Node analyzer, retrying once with a larger heap when it runs out of memory (634 TypeScript files, 2.9 MB,
+    needed more than the former fixed 512 MB)."""
+    for heap in NODE_HEAP_MB:
+        process=subprocess.run([web_search_adapters.NODE_EXECUTABLE,f'--max-old-space-size={heap}',str(Path(__file__).with_name(script))],
+            input=payload,capture_output=True,text=True,encoding='utf-8',timeout=120,
+            creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+        if process.returncode==0:
+            return json.loads(process.stdout)
+        if 'heap out of memory' not in (process.stderr or '') or heap==NODE_HEAP_MB[-1]:
+            break
+    detail=' (out of memory)' if 'heap out of memory' in (process.stderr or '') else ''
+    raise RuntimeError(failure+detail)
+
+
 def _javascript_graph(sources, all_paths=None):
     extensions=('.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts')
     relevant={path:text for path,text in sources.items() if path.endswith(extensions+('.json','.html','.htm'))}
     if not any(path.endswith(extensions) for path in relevant):
         return {}
     try:
-        process=subprocess.run([web_search_adapters.NODE_EXECUTABLE,'--max-old-space-size=512',str(Path(__file__).with_name('code_graph_js.cjs'))],
-            input=json.dumps({'files':[{'path':path,'text':text} for path,text in relevant.items()],'paths':list(all_paths or sources)},ensure_ascii=False),
-            capture_output=True,text=True,encoding='utf-8',timeout=40,
-            creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
-        if process.returncode:
-            raise RuntimeError('The TypeScript analyzer did not finish. Check the local code-analysis runtime.')
-        return json.loads(process.stdout)
+        return _run_analyzer('code_graph_js.cjs',
+                             json.dumps({'files':[{'path':path,'text':text} for path,text in relevant.items()],
+                                         'paths':list(all_paths or sources)},ensure_ascii=False),
+                             'The TypeScript analyzer did not finish. Check the local code-analysis runtime.')
     except (OSError,subprocess.TimeoutExpired,ValueError,RuntimeError) as exc:
         return {'diagnostics':[{'path':'JavaScript/TypeScript','reason':str(exc)[:250]}],'parsed':[],'retryable':True}
 
@@ -249,17 +266,17 @@ def _java_graph(sources):
     files=[{'path':path,'text':text} for path,text in sources.items() if path.lower().endswith('.java')]
     if not files:return {}
     try:
-        result=subprocess.run([web_search_adapters.NODE_EXECUTABLE,'--max-old-space-size=512',str(Path(__file__).with_name('code_graph_java.mjs'))],
-            input=json.dumps({'files':files},ensure_ascii=False),capture_output=True,text=True,encoding='utf-8',timeout=40,
-            creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
-        if result.returncode:raise RuntimeError('The Java analyzer did not finish. Check the local runtime.')
-        return json.loads(result.stdout)
+        return _run_analyzer('code_graph_java.mjs',json.dumps({'files':files},ensure_ascii=False),
+                             'The Java analyzer did not finish. Check the local runtime.')
     except (OSError,ValueError,RuntimeError,subprocess.TimeoutExpired) as exc:
         return {'diagnostics':[{'path':'Java','reason':str(exc)[:250]}],'parsed':[],'retryable':True}
 
 
 def _analyze(path):
-    files,sources,diagnostics,truncated=_snapshot(path)
+    return _analyze_sources(*_snapshot(path))
+
+
+def _analyze_sources(files,sources,diagnostics,truncated):
     merged={'symbols':[],'dependencies':[],'calls':[],'unresolved':[],'diagnostics':diagnostics,'parsed':[]}
     retryable=False
     for output in (_python_graph(sources),_javascript_graph(sources,[f['path'] for f in files]),_java_graph(sources),web_document_graph.analyze(sources,[f['path'] for f in files])):
@@ -401,3 +418,47 @@ def build(root,view_id=None,storage_id=None,file_path=None,background=False):
                 limits={'files':MAX_FILES,'symbols':MAX_SYMBOLS,'edges':MAX_EDGES,'display_nodes_default':120},
                 languages=['Java','Angular','Python','JavaScript','TypeScript','JSX','TSX','HTML','CSS','Markdown'],cache_hit=was_cached)
     return _focus(data,file_path) if file_path else data
+
+
+def build_overlay(root,changes,view_id=None):
+    """Graph of the indexed view with the given changed files read from the working tree instead of the snapshot
+    (changes: project-relative path -> 'deleted' or any other status), so a caller right after an edit sees new files,
+    new imports and current line numbers without reindexing or embeddings. A deleted file keeps its indexed copy so
+    the files that imported it stay linked to it. Cached per snapshot and file contents."""
+    inventory=index_inventory.inspect(root,view_id)
+    if not inventory['selected']:
+        return {**inventory,'symbols':[],'dependencies':[],'calls':[],'diagnostics':[],'counts':{},'files':[]}
+    path=inventory['selected']['path'];stat=os.stat(path)
+    files,sources,diagnostics,truncated=_snapshot(path)
+    by_path={f['path']:f for f in files};overlaid=[]
+    for rel,status in sorted(changes.items()):
+        full=os.path.join(root,rel)
+        if status=='deleted' or not project_identity.within_root(root,full):
+            continue
+        try:
+            if os.path.getsize(full)>MAX_OVERLAY_BYTES:continue
+            with open(full,encoding='utf-8') as stream:text=stream.read()
+        except (OSError,UnicodeDecodeError):continue
+        by_path.setdefault(rel,{'id':rel,'path':rel,'hash':None,'size':len(text),'mtime_ns':None,'chunks':0,
+                                'lines':text.count('\n')+1,'group':posixpath.dirname(rel) or '(root)',
+                                'location_kind':document_text.location_kind(rel),
+                                'format':posixpath.splitext(rel)[1].lower().lstrip('.') or 'text'})
+        if rel.lower().endswith(SOURCE_EXTENSIONS):
+            sources[rel]=text;overlaid.append((rel,hashlib.sha1(text.encode('utf-8')).hexdigest()))
+    key=(path,stat.st_mtime_ns,stat.st_size,VERSION,'overlay',tuple(overlaid))
+    with _LOCK:
+        cached=_CACHE.get(key)
+    if cached is None:
+        if not _ANALYSIS_SLOTS.acquire(timeout=3):
+            raise RuntimeError('Two map analyses are in progress. Wait for them to finish and retry.')
+        try:
+            cached=_analyze_sources(list(by_path.values()),sources,diagnostics,truncated)
+        finally:
+            _ANALYSIS_SLOTS.release()
+        if not cached['retryable']:
+            with _LOCK:
+                _CACHE[key]=cached
+                while len(_CACHE)>3:_CACHE.popitem(last=False)
+    data=copy.deepcopy(cached)
+    data.update(selected=inventory['selected'],source='indexed_snapshot_with_working_tree',overlaid=[r for r,_h in overlaid])
+    return data

package/code_graph_java.mjs

@@ -33,9 +33,12 @@ for(const unit of units){
  if(cls&&n.name==='primary'){
    const prefix=n.children.primaryPrefix?.[0],prefixText=text(unit,prefix).trim(),suffixes=n.children.primarySuffix||[];let chain=prefixText,fluent=false;
    const newMatch=/^new\s+([\w.$]+)/.exec(prefixText);let constructed=newMatch?resolveType(unit,newMatch[1],cls):null;
+   const link=(type,line)=>{if(type&&type.unit.path!==unit.path&&dependencies.length<MAX_EDGES)dependencies.push({source:unit.path,target:type.unit.path,specifier:type.fqn,line,kind:'java_type',resolution:'resolved'})};
    if(constructed&&calls.length<MAX_EDGES)calls.push({source:(owner||cls.symbol).id,target:constructed.symbol.id,line:n.location.startLine,kind:'construct',resolution:'static'});
+   link(constructed,n.location.startLine);
+   const staticHead=/^([A-Z][\w$]*)\./.exec(prefixText);if(staticHead&&!vars.has(staticHead[1]))link(resolveType(unit,staticHead[1],cls),n.location.startLine);
    for(const suffix of suffixes){const invoke=suffix.children.methodInvocationSuffix?.[0];if(!invoke){chain+=text(unit,suffix);continue}const args=invoke.children.argumentList?.[0],arity=args?(args.children.expression||[]).length:0;const match=/^(?:([\w.$]+)\.)?([\w$]+)$/.exec(chain);let target=null;
-     if(match&&!fluent){const receiver=match[1],name=match[2];let type=null;if(!receiver||receiver==='this')type=cls;else if(receiver==='super')type=resolveType(unit,cls.extends,cls);else if(receiver.startsWith('this.'))type=resolveType(unit,cls.fields.get(receiver.slice(5))||'',cls);else if(vars.has(receiver))type=resolveType(unit,vars.get(receiver)||'',cls);else type=resolveType(unit,receiver,cls);target=lookupMethod(type,name,arity);if(!target&&!receiver){const candidates=unit.imports.filter(i=>i.static&&(i.spec.endsWith('.'+name)||i.spec.endsWith('.*'))).map(i=>lookupMethod(classes.get(i.spec.split('.').slice(0,-1).join('.')),name,arity)).filter(Boolean);if(candidates.length===1)target=candidates[0]}}
+     if(match&&!fluent){const receiver=match[1],name=match[2];let type=null;if(!receiver||receiver==='this')type=cls;else if(receiver==='super')type=resolveType(unit,cls.extends,cls);else if(receiver.startsWith('this.'))type=resolveType(unit,cls.fields.get(receiver.slice(5))||'',cls);else if(vars.has(receiver))type=resolveType(unit,vars.get(receiver)||'',cls);else{type=resolveType(unit,receiver,cls);link(type,invoke.location.startLine)}target=lookupMethod(type,name,arity);if(!target&&!receiver){const candidates=unit.imports.filter(i=>i.static&&(i.spec.endsWith('.'+name)||i.spec.endsWith('.*'))).map(i=>lookupMethod(classes.get(i.spec.split('.').slice(0,-1).join('.')),name,arity)).filter(Boolean);if(candidates.length===1)target=candidates[0]}}
      if(constructed&&!fluent){const methodName=/\.([\w$]+)$/.exec(chain)?.[1];if(methodName)target=lookupMethod(constructed,methodName,arity)}
      if(target&&calls.length<MAX_EDGES)calls.push({source:(owner||cls.symbol).id,target:target.id,line:invoke.location.startLine,kind:'call',resolution:'static'});
      else if(unresolved.length<1000)unresolved.push({path:unit.path,line:invoke.location.startLine,expression:chain.slice(0,140),reason:'External/dynamic type, interface without implementation, or ambiguous overload in the Java snapshot.'});

package/code_graph_js.cjs

@@ -25,7 +25,19 @@ function candidate(base) {
   const variants=[base,base.replace(/\.[cm]?jsx?$/,'.ts'),base.replace(/\.jsx?$/,'.tsx'),
     ...['.ts','.tsx','.js','.jsx','.mts','.cts','.mjs','.cjs'].map(e=>base+e),
     ...['.ts','.tsx','.js','.jsx'].map(e=>base+'/index'+e)];
-  return variants.find(name=>knownFiles.has(clean(name)));
+  const found=variants.find(name=>knownFiles.has(clean(name)));
+  return found&&clean(found);
+}
+const workspaces=new Map();
+for(const [name,file] of docs)if(name.endsWith('/package.json')&&!name.includes('/node_modules/')){try{const pkg=JSON.parse(file.text);if(typeof pkg.name==='string'&&pkg.name)workspaces.set(pkg.name,{dir:path.dirname(name),entries:[pkg.source,pkg.main,pkg.module].filter(e=>typeof e==='string')})}catch{}}
+function workspace(spec){
+  for(const [name,pkg] of workspaces){
+    if(spec!==name&&!spec.startsWith(name+'/'))continue;
+    const sub=spec.slice(name.length+1);
+    if(sub)return candidate(path.join(pkg.dir,'src',sub))||candidate(path.join(pkg.dir,sub));
+    return candidate(path.join(pkg.dir,'src/index'))||candidate(path.join(pkg.dir,'index'))||pkg.entries.map(e=>candidate(path.join(pkg.dir,e))).find(Boolean);
+  }
+  return undefined;
 }
 function resolve(spec, from) {
   if (spec.startsWith('.')) return candidate(clean(path.join(path.dirname(from),spec)));
@@ -39,6 +51,8 @@ function resolve(spec, from) {
       }
     }
   }
+  const local=workspace(spec);
+  if(local)return local;
   if(config.baseUrl)return candidate(clean(path.join(baseUrl,spec)));
   return undefined;
 }