@allansantos-dev/smart-tool 0.9.3 → 0.9.5

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.9.5 - beta
+
+Reported by the claude-code-boss session on its first day using 0.9.4.
+
+- `affected_tests` answered "no tests" for a module covered by a 1.4 MB test file (1,427 cases): the file was over the
+  index size limit and the working-tree reading skipped files over 1 MB, so it fell out of the import graph silently.
+  Files up to 5 MB are now analyzed for the graph, and any tracked test file still outside it is selected ("may cover
+  the change") instead of disappearing.
+- Tests that run a script by path (`spawnSync('node', [path.join(SCRIPTS, 'hook.js')])`, `subprocess.run(["python",
+  "tools/x.py"])`) now depend on that script: a file name in a string literal of a test, resolved against the test's
+  folder, the folders above it and the project root, links them.
+- A test is left out of the list only when it has no test cases (`conftest.py`, fixtures, helpers). The former rule
+  ("imported by another test") dropped real Java tests that share test types: on gson it caught 19 of 28 injected
+  faults; now 28 of 28. JUnit 3 suites (`@RunWith(AllTests.class)`, `static Test suite()`) count as tests.
+- Test files named in `package.json` scripts (`"test": "node scripts/test-units.js"`) get a `node <file>` command.
+- An anonymous callback among the touched functions is named after the function that contains it.
+- `project_manage register` and `status` return the project with its last jobs summarized and without the scope's
+  folder structure and profile groups (`scope_summary` keeps include/exclude): they returned the full result of every
+  past search (108-128 thousand characters on one project, now 3.3 thousand). The projects screen keeps the full
+  payload.
+- A project is no longer marked `degraded` because the per-chunk function analysis was still being prepared: that note
+  is shown with the search results but is not a degradation.
+
+## 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

package/affected_tests.py

@@ -1,17 +1,19 @@
 """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,
+module, import distance). Test support files (conftest.py, fixtures and helpers without test cases) 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 posixpath
 import re
 import subprocess
 from collections import defaultdict, deque
 
 import code_graph
+import index_inventory
 import index_profile
 import index_scope
 
@@ -21,11 +23,16 @@ RUN_ALL = re.compile(
     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 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.")
+        "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.")
+TEST_SOURCES = (".py", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts", ".java")
+_PATH_LITERAL = re.compile(r"""['"`]((?:\.{0,2}/)?[\w.-]+(?:/[\w.-]+)*\.(?:py|js|mjs|cjs|ts|mts|cts|java))['"`]""")
 _HUNK = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", re.M)
 
 
@@ -118,6 +125,10 @@ def _commands(root, tests):
             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)
+            local = os.path.relpath(path, folder or ".").replace(os.sep, "/")
+            scripts = " ".join(str(v) for v in (package.get("scripts") or {}).values())
+            if runner is None and re.search(rf"\bnode\s+(\./)?{re.escape(local)}\b", scripts):
+                runner = "node-script"
             groups[(folder or "", runner)].append(path)
         elif lower.endswith(".java"):
             folder, name = _nearest(root, path, ("pom.xml", "build.gradle", "build.gradle.kts"))
@@ -134,6 +145,9 @@ def _commands(root, tests):
         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 == "node-script":
+            commands.extend({"cwd": folder or ".", "command": f"node {f}"} for f in sorted(local))
+            continue
         elif runner == "unittest-package":
             line = "python -m unittest " + " ".join(sorted(f[:-3].replace("/", ".") for f in files))
         elif runner == "unittest-folder":
@@ -190,12 +204,84 @@ def _fixture_users(root, test_files):
     return users
 
 
+def _path_literal_users(root, test_files, known):
+    """Code files a test names in a string literal ('graph-guard.js', "scripts/run.py"), resolved against the test's
+    folder, the folders above it and the project root: tests that run scripts as subprocesses or load them by path
+    (spawnSync('node', [path.join(SCRIPTS, 'hook.js')])) depend on them without importing them."""
+    users = defaultdict(set)
+    for test in test_files:
+        if not test.lower().endswith(TEST_SOURCES):
+            continue
+        source = _read(os.path.join(root, test))
+        folders, folder = [], os.path.dirname(test)
+        while True:
+            folders.append(folder)
+            if not folder:
+                break
+            folder = os.path.dirname(folder)
+        for literal in set(_PATH_LITERAL.findall(source)):
+            for base in folders:
+                candidate = posixpath.normpath(posixpath.join(base, literal.removeprefix("./")))
+                if candidate in known and candidate != test:
+                    users[candidate].add(test)
+                    break
+    return users
+
+
+_TEST_CASES = {
+    ".py": re.compile(r"^\s*(async\s+)?def\s+test\w*\s*\(|^\s*class\s+Test\w*|unittest\.TestCase", re.M),
+    ".java": re.compile(r"@(Test|ParameterizedTest|RepeatedTest|TestFactory|TestTemplate|RunWith|Suite)\b|"
+                        r"\bstatic\s+\w*Test\s+suite\s*\(|\bextends\s+TestCase\b|\bvoid\s+test\w*\s*\("),
+    "script": re.compile(r"\b(it|test|describe|suite)(\.\w+)?\s*\(|\bDeno\.test\b|\bnode:test\b|\bassert\b"),
+}
+
+
+def _support(root, path):
+    """Test-kind file without test cases (conftest.py, fixtures, helpers): it carries the selection but is not run.
+    A test referenced by another test (shared Java test types) is still a test."""
+    if os.path.basename(path) == "conftest.py":
+        return True
+    ext = os.path.splitext(path)[1].lower()
+    pattern = _TEST_CASES.get(ext) or (_TEST_CASES["script"] if ext in TEST_SOURCES else None)
+    source = _read(os.path.join(root, path))
+    return bool(pattern and source and not pattern.search(source))
+
+
+def _tracked_tests_outside_graph(root, parsed, profile):
+    """Code test files git tracks that the graph could not analyze (over the size limits, unreadable): their imports
+    are unknown, so they are selected instead of silently missing (a 1.4 MB test file covering 1,427 cases did)."""
+    listed = subprocess.run(["git", "ls-files", "-z"], cwd=root, capture_output=True, timeout=30)
+    if listed.returncode:
+        return []
+    tests = []
+    for rel in listed.stdout.decode("utf-8", "replace").split("\0"):
+        if rel and rel not in parsed and rel.lower().endswith(TEST_SOURCES) and os.path.basename(rel) != "conftest.py" \
+                and index_profile.kind(rel, profile) == "test" and os.path.isfile(os.path.join(root, rel)):
+            tests.append(rel)
+    return tests
+
+
+def _label(symbol, by_id):
+    """path::name of a touched function; an anonymous callback is named after the function that contains it."""
+    short = symbol["name"].split("(")[0].split(".")[-1]
+    if short in ("callback", "anonymous"):
+        parent = by_id.get(symbol.get("parent"))
+        while parent and parent["name"].split("(")[0].split(".")[-1] in ("callback", "anonymous"):
+            parent = by_id.get(parent.get("parent"))
+        if parent:
+            return f"{symbol['path']}::{parent['name']} (callback at line {symbol['start_line']})"
+    return f"{symbol['path']}::{symbol['name']}"
+
+
 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)
+    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 []}:
@@ -210,9 +296,13 @@ def affected(root, base="HEAD", limit=30, view_id=None):
         callers[call["target"]].add(call["source"])
     for conftest, users in _fixture_users(root, test_files).items():
         importers[conftest] |= users
+    for target, users in _path_literal_users(root, test_files, {f["path"] for f in data.get("files") or []}).items():
+        importers[target] |= 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":
@@ -251,9 +341,11 @@ def affected(root, base="HEAD", limit=30, view_id=None):
                 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}
+    selected = {test: reason for test, reason in selected.items() if not _support(root, test)}
+    if changed_code or conftests:
+        for test in _tracked_tests_outside_graph(root, parsed, profile):
+            selected.setdefault(test, "test file outside the import graph (too large or not analyzed): may cover "
+                                      "the change")
 
     def why(test):
         if selected[test]:
@@ -274,7 +366,7 @@ def affected(root, base="HEAD", limit=30, view_id=None):
         "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],
+        "touched_functions": [_label(s, by_id) 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),

package/code_graph.py

@@ -2,6 +2,7 @@
 import ast
 import collections
 import copy
+import gzip
 import contextvars
 import hashlib
 import json
@@ -14,6 +15,7 @@ from pathlib import Path
 
 import indexer
 import index_inventory
+import index_scope
 import project_identity
 import web_search_adapters
 import web_document_graph
@@ -21,7 +23,7 @@ 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_OVERLAY_BYTES = 5 * 1024 * 1024
 MAX_FILES = 3000
 MAX_TEXT = 24 * 1024 * 1024
 MAX_SYMBOLS = 8000
@@ -339,6 +341,41 @@ def _by_file(data):
     return {'symbols':by_file,'parsed':parsed,'note':note}
 
 
+def _disk_path(view_path):
+    path=indexer.graph_cache_path(view_path)
+    return os.path.dirname(path),path
+
+
+def _disk_load(key):
+    """Analysis saved for exactly this index state and analyzer version, or None. A damaged file is a miss: the
+    caller analyzes again and overwrites it."""
+    _folder,path=_disk_path(key[0])
+    try:
+        with gzip.open(path,'rt',encoding='utf-8') as stream:
+            saved=json.load(stream)
+    except (OSError,EOFError,ValueError):
+        return None
+    return saved.get('graph') if saved.get('key')==[key[1],key[2],key[3]] else None
+
+
+def _disk_save(key,data):
+    """Writes the analysis next to the index (atomic replace) and removes caches of views that no longer exist.
+    Returns the error text when it could not be written, so the caller can report it."""
+    folder,path=_disk_path(key[0])
+    try:
+        os.makedirs(folder,exist_ok=True)
+        temporary=f'{path}.{os.getpid()}.{threading.get_ident()}.tmp'
+        with gzip.open(temporary,'wt',encoding='utf-8',compresslevel=5) as stream:
+            json.dump({'key':[key[1],key[2],key[3]],'graph':data},stream,ensure_ascii=False)
+        os.replace(temporary,path)
+        for name in os.listdir(folder):
+            if name.endswith('.json.gz') and not os.path.isfile(os.path.join(os.path.dirname(folder),name[:-8]+'.sqlite3')):
+                os.remove(os.path.join(folder,name))
+    except OSError as exc:
+        return f'Graph cache not saved ({type(exc).__name__}: {exc}); the next restart analyzes again.'[:300]
+    return None
+
+
 def cached_symbols(root):
     path=indexer.existing_db_path(root)
     if not path:
@@ -348,6 +385,13 @@ def cached_symbols(root):
         data=_CACHE.get(key)
         if data is not None:
             _CACHE.move_to_end(key)
+    if data is None:
+        data=_disk_load(key)
+        if data is not None:
+            with _LOCK:
+                _CACHE[key]=data
+                while len(_CACHE)>3:_CACHE.popitem(last=False)
+    with _LOCK:
         state=_WARM_STATE.get(root)
         if data is None and state and state['key']==key and (state['result'] or time.time()-state['at']<WARM_RETRY_S):
             return state['result'],state['note']
@@ -361,6 +405,12 @@ def cached_symbols(root):
     return None,None
 
 
+def warm(root):
+    """Starts the analysis of the project's current index in the background unless memory or disk already has it, so
+    the next edit hook or search finds the graph ready (called when an indexing job ends)."""
+    cached_symbols(root)
+
+
 def _warm(root,key):
     result,note=None,None
     try:
@@ -388,6 +438,13 @@ def build(root,view_id=None,storage_id=None,file_path=None,background=False):
         cached=_CACHE.get(key)
         if cached:_CACHE.move_to_end(key)
     was_cached=cached is not None
+    save_note=None
+    if cached is None:
+        cached=_disk_load(key)
+        if cached is not None:
+            with _LOCK:
+                _CACHE[key]=cached
+                while len(_CACHE)>3:_CACHE.popitem(last=False)
     if cached is None:
         slots=_WARM_SLOT if background else _ANALYSIS_SLOTS
         if not slots.acquire(timeout=None if background else 3):
@@ -401,7 +458,9 @@ def build(root,view_id=None,storage_id=None,file_path=None,background=False):
             with _LOCK:
                 _CACHE[key]=cached
                 while len(_CACHE)>3:_CACHE.popitem(last=False)
+            save_note=_disk_save(key,cached)
     data=copy.deepcopy(cached)
+    if save_note:data['diagnostics']=[*data.get('diagnostics',[]),{'path':'','reason':save_note}]
     # Só compara metadados do diretório de trabalho quando a visão é a atual.
     for file in data['files']:
         file['status']='stored'
@@ -420,6 +479,72 @@ def build(root,view_id=None,storage_id=None,file_path=None,background=False):
     return _focus(data,file_path) if file_path else data
 
 
+def working_tree_changes(root):
+    """Project-relative paths changed in the git working tree (staged, unstaged, untracked) -> 'deleted' or
+    'changed'; empty when the folder is not in a git repository."""
+    def git(*args):
+        return subprocess.run(['git',*args],cwd=root,capture_output=True,timeout=30,
+                              creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+    prefix=git('rev-parse','--show-prefix')
+    if prefix.returncode:
+        return {}
+    prefix=prefix.stdout.decode('utf-8','replace').strip()
+    status=git('status','--porcelain=v1','-z','--untracked-files=all','--','.')
+    if status.returncode:
+        raise RuntimeError('git status failed: '+status.stderr.decode('utf-8','replace').strip()[:200])
+    entries=status.stdout.decode('utf-8','replace').split('\0');changes={};i=0
+    while i<len(entries):
+        entry=entries[i];i+=1
+        if len(entry)<4:continue
+        code,path=entry[:2],entry[3:]
+        if 'R' in code or 'C' in code:i+=1
+        if path.startswith(prefix):changes[path[len(prefix):]]='deleted' if 'D' in code else 'changed'
+    return changes
+
+
+def pending_changes(root,view_path):
+    """Files the indexed view does not reflect yet: working-tree changes, indexed files whose size or modification time
+    differs on disk, and files tracked by git inside the index scope that were never indexed (commits made after the
+    last indexing). Path -> 'deleted' or 'changed'."""
+    changes=working_tree_changes(root)
+    conn=indexer._readonly(view_path)
+    try:
+        columns={row[1] for row in conn.execute('PRAGMA table_info(manifest)')}
+        if not {'size','mtime_ns'} <= columns:
+            raise RuntimeError('Index without file sizes and times; reindex the project.')
+        rows=conn.execute('SELECT path,size,mtime_ns FROM manifest').fetchall()
+    finally:
+        conn.close()
+    indexed=set()
+    for original,size,stamp in rows:
+        rel=original.replace('\\','/');indexed.add(rel)
+        if rel in changes:continue
+        try:
+            stat=os.stat(os.path.join(root,rel))
+        except OSError:
+            changes[rel]='deleted';continue
+        if (stat.st_size,stat.st_mtime_ns)!=(size,stamp):changes[rel]='changed'
+    scope=index_scope.load_scope(root)
+    listed=subprocess.run(['git','ls-files','-z'],cwd=root,capture_output=True,timeout=30,
+                          creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+    if scope and listed.returncode==0:
+        for rel in listed.stdout.decode('utf-8','replace').split('\0'):
+            if rel and rel not in indexed and rel not in changes and rel.lower().endswith(SOURCE_EXTENSIONS) \
+                    and index_scope.in_scope(scope,rel) and os.path.isfile(os.path.join(root,rel)):
+                changes[rel]='changed'
+    return changes
+
+
+def build_current(root,view_id=None):
+    """The graph an agent should see while editing: the indexed view plus every file it does not reflect yet (see
+    pending_changes and build_overlay) when that view is the current one; a pinned or older view is returned as
+    indexed."""
+    inventory=index_inventory.inspect(root,view_id)
+    selected=inventory.get('selected') or {}
+    changes=pending_changes(root,selected['path']) if selected.get('current') else {}
+    return build_overlay(root,changes,view_id) if changes else build(root,view_id)
+
+
 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,

package/code_impact.py

@@ -10,7 +10,7 @@ import index_profile
 import index_scope
 
 MAX_DEPTH = 4
-NOTE = ("Static analysis of the indexed snapshot: calls made through callbacks, dynamic dispatch or names built at "
+NOTE = ("Static analysis of the indexed snapshot plus the files changed in the working tree: calls made through callbacks, dynamic dispatch or names built at "
         "runtime are not seen, so treat an empty list as 'none found', not as 'none exist'.")
 
 
@@ -54,7 +54,7 @@ def impact(root, symbol, view_id=None, depth=3, limit=30):
         raise ValueError("Pass symbol: a function, method (Class.method) or class name.")
     if type(depth) is not int or not 1 <= depth <= MAX_DEPTH:
         raise ValueError(f"depth must be an integer from 1 to {MAX_DEPTH}.")
-    data = code_graph.build(root, view_id)
+    data = code_graph.build_current(root, view_id)
     found = _matches(data.get("symbols") or [], symbol)
     diagnostics = [d.get("reason") for d in data.get("diagnostics") or [] if d.get("reason")]
     if not found:

package/doc_check.py

@@ -229,7 +229,7 @@ def coverage(root, include_tests=False, limit=30, view_id=None):
     """Docstring coverage of the indexed code: functions the language convention expects documented (plus any already
     documented) and those still missing, file by file, so an agent can document a project that started without it.
     Tests are left out unless include_tests."""
-    data = code_graph.build(root, view_id)
+    data = code_graph.build_current(root, view_id)
     profile = index_profile.current((index_scope.load_scope(root) or {}).get("profile"))
     kinds = ("code", "test") if include_tests else ("code",)
     by_path = defaultdict(list)

package/duplicates.py

@@ -9,6 +9,7 @@ import threading
 import time
 
 import code_graph
+import doc_check
 import embedding_cache
 import index_inventory
 import index_profile
@@ -169,15 +170,10 @@ def _functions(root, include_tests):
             if any(o is not s and o["start_line"] <= s["start_line"] and s["end_line"] <= o["end_line"]
                    and (o["start_line"], o["end_line"]) != (s["start_line"], s["end_line"]) for o in symbols):
                 continue
-            text = "\n".join(file_lines[s["start_line"] - 1:s["end_line"]])
-            if not text.strip():
+            entry = _entry(path, s["name"], s["start_line"], s["end_line"], file_lines, ext)
+            if entry is None:
                 continue
-            body = _strip_comments(_body(text, ext), ext)
-            normalized = re.sub(r"\s+", " ", body).strip()
-            name = s["name"].split("(")[0].split(".")[-1]
-            functions.append({"name": name, "path": path, "line": s["start_line"],
-                              "end": s["end_line"], "lines": s["end_line"] - s["start_line"] + 1, "text": text[:MAX_TEXT],
-                              "hash": hashlib.sha1(normalized.encode("utf-8")).hexdigest(), **_features(body, ext, name)})
+            functions.append(entry)
             occurrence = occurrences[functions[-1]["hash"]] = occurrences.get(functions[-1]["hash"], 0) + 1
             functions[-1]["kind"] = kind
             functions[-1]["fp"] = hashlib.sha1(f"{path}\0{functions[-1]['hash']}\0{occurrence}".encode("utf-8")).hexdigest()
@@ -191,6 +187,43 @@ def _functions(root, include_tests):
     return functions, notes, view
 
 
+def _entry(path, name, start, end, file_lines, ext):
+    """One function as the duplicate checks compare it: normalized body hash and near-duplicate features."""
+    text = "\n".join(file_lines[start - 1:end])
+    if not text.strip():
+        return None
+    body = _strip_comments(_body(text, ext), ext)
+    normalized = re.sub(r"\s+", " ", body).strip()
+    short = name.split("(")[0].split(".")[-1]
+    return {"name": short, "path": path, "line": start, "end": end, "lines": end - start + 1, "text": text[:MAX_TEXT],
+            "hash": hashlib.sha1(normalized.encode("utf-8")).hexdigest(), **_features(body, ext, short)}
+
+
+def _working_tree_functions(root, changes, profile):
+    """Production functions of the files changed in the working tree, read from disk, so a copy of a function written
+    earlier in the same session is caught before the index catches up."""
+    found = []
+    for rel, status in changes.items():
+        ext = rel.rsplit(".", 1)[-1].lower() if "." in rel else ""
+        if status == "deleted" or ext not in _LANG or index_profile.kind(rel, profile) != "code":
+            continue
+        try:
+            with open(os.path.join(root, rel), encoding="utf-8") as stream:
+                source = stream.read()
+        except (OSError, UnicodeDecodeError):
+            continue
+        if _GENERATED.search(source[:4000]):
+            continue
+        lines = source.splitlines()
+        for function in doc_check.functions(rel, source):
+            if function["end"] - function["start"] + 1 < MIN_LINES:
+                continue
+            entry = _entry(rel, function["name"], function["start"], function["end"], lines, ext)
+            if entry:
+                found.append({**entry, "kind": "code"})
+    return found
+
+
 def _ref(f):
     return {"name": f["name"], "path": f["path"], "lines": f"{f['line']}-{f['end']}"}
 
@@ -381,8 +414,9 @@ def find(root, embed, configured_model, min_similarity=DEFAULT_MIN_SIMILARITY, i
 
 
 def _write_pool(root):
-    """Indexed production functions with their idiom shingles, rebuilt only when the index changes; None while the
-    code graph is not cached yet, so an edit hook never waits for an analysis."""
+    """Indexed production functions with their idiom shingles, with the files changed in the working tree read from
+    disk (see code_graph.pending_changes). The indexed part is rebuilt only when the index changes and the changed
+    files on every call (an edit hook sees what earlier edits and commits wrote). None while the code graph is not cached yet, so a hook never waits for it."""
     view_path = indexer.existing_db_path(root)
     if not view_path or code_graph.cached_symbols(root)[0] is None:
         return None
@@ -390,13 +424,16 @@ def _write_pool(root):
     with _LOCK:
         cached = _WRITE_POOLS.get(root)
     if cached and cached[0] == state:
-        return cached[1]
-    functions, _notes, _view = _functions(root, False)
-    production = [f for f in functions if f["kind"] == "code"]
-    pool = (production, _idioms(production))
-    with _LOCK:
-        _WRITE_POOLS[root] = (state, pool)
-    return pool
+        indexed = cached[1]
+    else:
+        functions, _notes, _view = _functions(root, False)
+        indexed = [f for f in functions if f["kind"] == "code"]
+        with _LOCK:
+            _WRITE_POOLS[root] = (state, indexed)
+    changes = code_graph.pending_changes(root, view_path)
+    profile = index_profile.current((index_scope.load_scope(root) or {}).get("profile"))
+    production = [f for f in indexed if f["path"] not in changes] + _working_tree_functions(root, changes, profile)
+    return production, _idioms(production)
 
 
 def on_write(root, path, before, after, written):

package/hook_decision.py

@@ -16,6 +16,8 @@ import config
 import doc_check
 import duplicates
 import edit_preview
+import index_profile
+import index_scope
 import endpoint_sync
 import project_store
 import router
@@ -116,9 +118,10 @@ def _duplicate_lines(findings):
 
 
 def _edit_review(payload, doc_mode, duplicate_mode):
-    """Checks of an edit before it runs. Docstrings follow doc_mode: missing ones deny the edit in require mode and
-    become a reminder in remind mode; a documented function whose signature changed always gets a reminder. Copies of
-    indexed functions follow duplicate_mode and only add context, never deny."""
+    """Checks of an edit before it runs. Docstrings follow doc_mode, in code files of registered projects only (tests,
+    docs and files outside a project are left out, as in the docs coverage): missing ones deny the edit in require mode and become a reminder in remind mode; a
+    documented function whose signature changed always gets a reminder. Copies of indexed functions follow
+    duplicate_mode and only add context, never deny."""
     doc_findings, duplicate_findings, failures = [], [], []
     for path, before, after in edit_preview.preview(payload.get("tool_name"), payload.get("tool_input"), payload.get("cwd")):
         if not doc_check.supported(path):
@@ -126,7 +129,8 @@ def _edit_review(payload, doc_mode, duplicate_mode):
         root = _project_of(path)
         rel = os.path.relpath(path, root).replace(os.sep, "/") if root else os.path.basename(path)
         edited = doc_check.written(path, before, after)
-        if doc_mode != "off":
+        profile = index_profile.current((index_scope.load_scope(root) or {}).get("profile")) if root else None
+        if doc_mode != "off" and root and index_profile.kind(rel, profile) == "code":
             doc_findings += [(root, rel, item) for item in doc_check.review(path, before, after, edited)]
         if duplicate_mode != "off" and root and edited["touched"]:
             try:

package/index_scope.py

@@ -415,6 +415,22 @@ def _exclude_matcher(exclude):
     return matches
 
 
+def in_scope(scope, rel_path):
+    """Whether resolve_included_files would list rel_path: under an include base, outside the exclusions and outside
+    hidden folders."""
+    rel_path = rel_path.replace("\\", "/")
+    include = scope.get("include") or [""]
+    matcher = _exclude_matcher(set(scope.get("exclude") or []) | set(scope.get("user_exclude") or []) |
+                               _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
+    parts = rel_path.split("/")
+    if matcher(rel_path) or any(part.startswith(".") for part in parts[:-1]):
+        return False
+    if any(base in ("", ".") for base in include):
+        return True
+    return len(parts) == 1 or any(rel_path == base.strip("/") or rel_path.startswith(base.strip("/") + "/")
+                                  for base in include)
+
+
 def resolve_included_files(root, scope, cancel_check=None):
     if not valid_scope(scope):
         raise ValueError("Invalid scope; request a new project analysis.")

package/indexer.py

@@ -841,6 +841,12 @@ def search(root, query_vector=None, top_k=20, query=None, model_id=None, include
     return [(scores[chunk_id], *by_id[chunk_id][1:5]) for chunk_id in ids[:top_k]]
 
 
+def graph_cache_path(view_path):
+    """Where code_graph keeps the saved analysis of one index view (graph-cache/<view>.json.gz next to it)."""
+    return os.path.join(os.path.dirname(view_path), "graph-cache",
+                        os.path.basename(view_path).removesuffix(".sqlite3") + ".json.gz")
+
+
 def remove_index(root):
     """Remove somente arquivos de índice da raiz conhecida, nunca arquivos do projeto."""
     import glob
@@ -855,6 +861,10 @@ def remove_index(root):
                 except PermissionError as exc:
                     raise RuntimeError("The index is open in another process. Close the external reader and try removing it again.") from exc
                 removed.append(safe)
+                try:
+                    os.remove(graph_cache_path(safe))
+                except FileNotFoundError:
+                    pass
     invalidate_cache(root)
     return removed
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharper tools than their built-in search. Windows.",
   "license": "Apache-2.0",
   "author": "Allan Santos",

package/router.py

@@ -292,18 +292,21 @@ def log_unavailable(tool_name, tool_input, exc):
     )
 
 
-# Verbo ancorado no início do comando ou de um segmento (`|`, `;`, `&&`, `$(`): casar por
-# substring solta faria qualquer palavra inglesa dentro de um heredoc Python contar como
-# busca. A ausência de verbo é prova mecânica de que o `command` não busca código.
+# Search/read verbs count only where they start a command: at the beginning, after `;`, `&&`, `||`, `$(`, a backtick,
+# a loop/if keyword or a shell invoker (`bash -c`, `powershell -Command`, `cmd /c`). After a single `|` they filter the
+# output of the command before them (`python x.py | tail -5`), which reads no source code.
 _SEARCH_VERB_RE = re.compile(
-    # Início, separador de segmento, ou logo depois de um invocador de shell
-    # (`powershell -Command`, `bash -c`, `cmd /c`), que é como o verbo real costuma
-    # aparecer no meio de um comando em máquina Windows.
-    r"(?:^|[|;&]|\$\(|`|-c\s|-Command\s|/c\s|/k\s)\s*(?:sudo\s+|command\s+)?"
+    r"(?:^|[;&]|\|\||\$\(|`|-c\s|-Command\s|/c\s|/k\s)\s*[\"']?\s*(?:(?:do|then|else)\s+)?(?:sudo\s+|command\s+)?"
     r"(grep|egrep|fgrep|rg|ripgrep|find|findstr|fd|cat|type|head|tail|less|more|"
     r"ls|dir|awk|sed|ack|ag|select-string|sls|get-content|gc|get-childitem|gci)\b",
     re.IGNORECASE,
 )
+# Commands that read code or pages without a search verb at their start: their pipe filters still search content.
+_READ_PRODUCER_RE = re.compile(
+    r"\bgit\s+(grep|ls-files|show|log\s+-p|diff)\b|\b(curl|wget|iwr|invoke-webrequest)\b|\bgh\s+api\b|"
+    r"readFileSync|read_text\(|open\(",
+    re.IGNORECASE,
+)
 _READ_TOOLS = frozenset({"Read", "NotebookRead"})
 
 BREAKER_PATH = os.path.join(os.path.dirname(METRICS_PATH), "router-breaker.json")
@@ -318,14 +321,17 @@ def _mechanical_decision(tool_name, tool_input):
     Medido em 1973 decisões reais: 97,8% eram `allow`, e 1512 delas (77%) caíam nestes
     casos — cada uma custando uma ida ao gateway antes de toda tool call do agente. Os
     dois únicos `Read` redirecionados nesse histórico eram decisões erradas (um deles com
-    `offset`/`limit` explícitos, onde só as linhas pedidas servem)."""
+    `offset`/`limit` explícitos, onde só as linhas pedidas servem). Remedido em 2026-10-08
+    sobre 2488 Bash que foram ao modelo (mediana 1,5 s, 7,8% redirecionados): ignorar os
+    filtros depois de `|` (salvo quando o produtor lê código ou páginas) decide 439 deles
+    sem modelo (13,3 min em 58 h) e perde 1 dos 155 redirecionamentos."""
     if tool_name in _READ_TOOLS:
         return "allow", "Reading a specific file is never replaced by semantic search."
     if tool_name == "Bash":
         command = tool_input.get("command")
         if not isinstance(command, str) or not command.strip():
             return "allow", "Bash without a readable command."
-        if not _SEARCH_VERB_RE.search(command):
+        if not _SEARCH_VERB_RE.search(command) and not _READ_PRODUCER_RE.search(command):
             return "allow", "The command neither searches nor reads source code."
     return None
 

package/smart_tool_daemon.py

@@ -860,6 +860,8 @@ def _prepare_project_index(arguments, job_id, cfg, token, query_vector=None, pre
     if not stats.get("ready", True):
         raise RuntimeError(f"{stats.get('failed', 0)} file(s) could not be read consistently. Resume indexing.")
     project_store.confirm_changes(project_identity.project_id(root), project.get('dirty_seq', 0))
+    import code_graph
+    code_graph.warm(root)
     if lexical:
         stats["warning"] = LEXICAL_WARNING
     return stats
@@ -966,8 +968,10 @@ def _perform_smart_search_isolated(arguments, job_id):
                                      else ({}, None))
     except Exception as exc:
         symbol_index, symbol_note = None, f"Function analysis failed: {_project_error(exc)}"
+    notes = []
     if symbol_index is None and any(group != "doc" for group in groups):
-        warnings.append(symbol_note or "Per-chunk functions are being prepared; they will show on the next search.")
+        (warnings if symbol_note else notes).append(
+            symbol_note or "Per-chunk functions are being prepared; they will show on the next search.")
     elif symbol_note or (symbol_index or {}).get("note"):
         warnings.append(symbol_note or symbol_index["note"])
     query_terms = _symbol_terms(" ".join(queries[group] for group in groups if group != "doc"))
@@ -1011,7 +1015,7 @@ def _perform_smart_search_isolated(arguments, job_id):
     warning = " ".join(warnings)
     if warning:
         _update_job(job_id, warning=warning)
-    return _grouped_yaml(index_profile.public(profile), blocks, warning)
+    return _grouped_yaml(index_profile.public(profile), blocks, " ".join(warnings + notes))
 
 
 def _perform_project_index(arguments, job_id, preview=False):
@@ -1715,11 +1719,31 @@ def _project_action_locked(arguments):
     return {"project": _project_payload(project_store.get(key))}
 
 
+def _for_agent(result):
+    """register/status for an agent: the project without the full result of every past job, the folder structure of
+    the scope and the profile groups (one project returned 128 thousand characters, more than an MCP client shows);
+    scope_summary keeps include/exclude. The projects screen keeps the full payload."""
+    project = result.get("project") if isinstance(result, dict) else None
+    if isinstance(project, dict) and isinstance(project.get("jobs"), list):
+        project["jobs"] = [{key: job.get(key) for key in ("job_id", "status", "kind", "phase", "updated_at", "warning",
+                                                          "error") if job.get(key) not in (None, "")}
+                           for job in project["jobs"][:5]]
+    if isinstance(project, dict):
+        if isinstance(project.get("preview"), dict):
+            project["preview"] = {key: project["preview"].get(key)
+                                  for key in ("included_files", "eligible_files", "bytes", "skipped")}
+        project.pop("scope", None)
+    return result
+
+
 def _handle_project_manage(arguments):
     # MCP não abre janelas; o seletor nativo pertence apenas à interface local.
     if isinstance(arguments, dict) and arguments.get("action") == "pick":
         raise ValueError("Use register with project_root or pick the folder from the tray.")
-    return _to_json_sanitized(_project_action(arguments))
+    result = _project_action(arguments)
+    if isinstance(arguments, dict) and arguments.get("action") in ("register", "status"):
+        result = _for_agent(result)
+    return _to_json_sanitized(result)
 
 
 def _enqueue_monitored_project(project_id, **options):

package/version.py

@@ -1,7 +1,7 @@
 """Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
 import re
 
-VERSION = "0.9.3"
+VERSION = "0.9.5"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")