@allansantos-dev/smart-tool 0.9.3 → 0.9.4

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # 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

package/affected_tests.py

@@ -12,6 +12,7 @@ import subprocess
 from collections import defaultdict, deque
 
 import code_graph
+import index_inventory
 import index_profile
 import index_scope
 
@@ -21,11 +22,14 @@ 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.")
 _HUNK = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", re.M)
 
 
@@ -195,7 +199,10 @@ def affected(root, base="HEAD", limit=30, view_id=None):
     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 []}:
@@ -213,6 +220,8 @@ def affected(root, base="HEAD", limit=30, view_id=None):
     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":

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
@@ -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.4",
   "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

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.4"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")