@allansantos-dev/smart-tool 0.9.26 → 0.9.28

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.9.28 - beta
+
+- Node, npx and npm are looked up when they are needed, never remembered. A process keeps the PATH it was born with:
+  the tray started at logon never saw a Node installed, moved or removed afterwards, so the automatic update
+  (`npx --yes ... install`, run from the tray) stopped working once Node changed place, and everything the update then
+  started (installer, restarted tray) inherited the same stale PATH. New `node_locator.py`: the process PATH, then the
+  machine and user PATH stored in the registry, then the usual install folders (Program Files, nvm, Volta, fnm, Scoop,
+  Chocolatey); the Node inside Smart Tool (`web_adapters/node/.node-runtime`) is used only when the machine has none.
+  - The updater launches the install with that fresh PATH and the folder of the `npx` it found first in it.
+  - The web runtime installer takes the machine's Node from the PATH first (it preferred the one inside Smart Tool).
+  - Search adapters and the code analyzers resolve Node at each launch, so a Node changed while the daemon runs is
+    followed without a restart.
+  - The Playwright MCP registration writes the absolute Node path into the client's configuration; the daemon now
+    registers it again at start when that executable no longer exists (`browser_control.heal`).
+- Tests: `tests/test_node_locator.py` (Node in an unusual folder, only in the registry PATH, only in a known folder,
+  nothing found, the updater without npx in the tray PATH, a registration whose Node is gone).
+
+## 0.9.27 - beta
+
+- No folder is read before it is classified, and a tool's hidden folder (`.crowd`, `.tokenguard`, `.vscode`, any name
+  starting with a dot) is never indexed, whatever the scope says:
+  - An empty or missing `include` used to mean "the whole project" (the saved scopes of `sistema` and a Claude memory
+    folder had `include: []`), and a search of a folder with no index and no scope read every file of it from disk (one
+    registered folder had 715 427). An empty `include` now indexes only the loose files at the root, and that first
+    keyword search reads only those.
+  - The `scope` action without a saved scope defaulted to `include: ["."]`; it now requires `include`, and refuses an
+    include inside a hidden folder.
+  - A model that answered with `docs/**`, `*` or `**/*` (the cause of the `error` status of two registered folders)
+    now has the entry reduced to the folder it names; an entry that is absolute, climbs out with `..`, sits in a hidden
+    folder or keeps a wildcard in the middle is dropped and kept in `dropped_include` of the saved scope.
+  - Hidden files at the root and inside any included folder are no longer listed (they were listed and then skipped
+    when read).
+  - The mechanical exclusion grows: `site-packages`, `bower_components`, `jspm_packages` everywhere, and `target`
+    (Cargo.toml or pom.xml at the root) and `Pods` (Podfile). These are never offered to the scope model.
+- Tests for each rule: `tests/test_scope_rules.py`.
+
 ## 0.9.26 - beta
 
 - The daemon no longer re-reads and re-hashes every watched folder in a loop. Measured on the owner's machine: one

package/README.md

@@ -15,7 +15,7 @@ registered as the `playwright` server where this machine lets a browser be drive
 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.
 
-**Status:** 0.9.26 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.28 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 

package/browser_control.py

@@ -26,6 +26,7 @@ import tomllib
 import atomic_io
 import endpoint_sync
 import install_runtime
+import node_locator
 import paths
 
 SERVER = "playwright"
@@ -157,6 +158,34 @@ def registered():
     return found
 
 
+def registered_command(client):
+    """Executable the client's `playwright` server is registered with, or None when it is not registered."""
+    try:
+        if client == "claude":
+            with open(endpoint_sync.claude_json(), encoding="utf-8") as stream:
+                entry = (json.load(stream).get("mcpServers") or {}).get(SERVER)
+        else:
+            with open(_codex_config(), encoding="utf-8") as stream:
+                entry = (tomllib.loads(stream.read()).get("mcp_servers") or {}).get(SERVER)
+    except (OSError, ValueError, AttributeError):
+        return None
+    command = entry.get("command") if isinstance(entry, dict) else None
+    return command if isinstance(command, str) else None
+
+
+def heal(log=None):
+    """Registers again, through ensure, each registration of ours whose executable no longer exists: the Node path is
+    written into the client's configuration, which a moved or reinstalled Node leaves pointing nowhere. Returns
+    {client: ensure's outcome} for the clients refreshed."""
+    refreshed = {}
+    for client in ("claude", "codex"):
+        command = registered_command(client)
+        ours = status().get(client, {}).get("state") in ("registered", "undenied")
+        if ours and command and not node_locator.exists(command):
+            refreshed[client] = ensure(client, log)
+    return refreshed
+
+
 def _codex_config():
     """Codex keeps config.toml in CODEX_HOME when set, else ~/.codex."""
     return os.path.join(endpoint_sync.codex_dir(), "config.toml")

package/code_graph.py

@@ -242,7 +242,7 @@ def _run_analyzer(script, payload, failure):
     needed more than the former fixed 512 MB). The run is killed after `ANALYZER_TIMEOUT_S` seconds (a context
     variable: the edit hook lowers it so a slow file cannot hold its worker)."""
     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))],
+        process=subprocess.run([web_search_adapters.executable_path(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=ANALYZER_TIMEOUT_S.get(),
             creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
         if process.returncode==0:

package/index_scope.py

@@ -28,8 +28,18 @@ SCOPE_DIR = paths.DATA_DIR
 _ALWAYS_EXCLUDE = {
     ".git", "node_modules", "__pycache__", ".venv", "venv", "env",
     ".tox", ".mypy_cache", ".pytest_cache", "*.egg-info",
+    "site-packages", "bower_components", "jspm_packages",
 }
 
+# Folders that are generated output only when the root proves the project type: a root marker file maps to the names
+# it makes unambiguous (Cargo's and Maven's `target`, CocoaPods' `Pods`). Excluded mechanically, before any model sees
+# the folder list.
+_PROJECT_TYPE_EXCLUDES = (
+    (("Cargo.toml",), ("target",)),
+    (("pom.xml",), ("target",)),
+    (("Podfile",), ("Pods",)),
+)
+
 # Mesmo critério do `_ALWAYS_EXCLUDE`, para arquivo: o significado não varia por
 # projeto. Lockfile é grafo de dependência resolvido por ferramenta — nunca é fonte de
 # resposta numa busca semântica, e é grande o bastante pra dominar o índice.
@@ -55,6 +65,51 @@ def tool_state_excludes(root):
     return _TOOL_STATE_DIRS.get(os.path.basename(os.path.normpath(root)).casefold(), ())
 
 
+def project_type_excludes(root):
+    """Names of the generated-output folders `root`'s marker files make unambiguous (empty for an unknown type)."""
+    found = []
+    for markers, names in _PROJECT_TYPE_EXCLUDES:
+        if any(os.path.isfile(os.path.join(root, marker)) for marker in markers):
+            found.extend(names)
+    return tuple(found)
+
+
+def mechanical_excludes(root):
+    """Everything excluded without asking a model: the tool-runtime folders of a config home and the generated output
+    of the project type. The names of `_ALWAYS_EXCLUDE` and every hidden folder are excluded on top of these."""
+    return (*tool_state_excludes(root), *project_type_excludes(root))
+
+
+def is_hidden(rel_path):
+    """Whether any part of the relative path starts with a dot (a tool's folder: .git, .vscode, .crowd, .tokenguard)."""
+    return any(part.startswith(".") for part in str(rel_path).replace("\\", "/").split("/") if part not in ("", ".", ".."))
+
+
+def normalize_include(include):
+    """`(bases, dropped)` from the include entries of a scope. A base is a folder or file path relative to the root, with
+    the shapes a model emits for "everything under it" (`docs/**`, `docs/*`, `docs/`) reduced to the folder; `*`, `**`
+    and `**/*` mean the whole project and become ``. An entry that is absolute, climbs out with `..`, sits inside a hidden
+    folder or keeps a wildcard in the middle is dropped: it can never name something indexable, and it is returned so the
+    caller can report it. No entries means no folder: only the loose files at the root are indexed."""
+    bases, dropped = [], []
+    for raw in include or []:
+        base = str(raw).replace("\\", "/").strip()
+        while base.startswith("./"):
+            base = base[2:]
+        for tail in ("/**/*", "/**", "/*"):
+            if base.endswith(tail):
+                base = base[:-len(tail)]
+        base = base.strip("/")
+        if base in ("*", "**", "**/*", "."):
+            base = ""
+        if (os.path.isabs(str(raw)) or str(raw).strip().startswith(("/", "\\")) or ".." in base.split("/") or is_hidden(base)
+                or any(ch in base for ch in "*?[")):
+            dropped.append(raw)
+        elif base not in bases:
+            bases.append(base)
+    return bases, dropped
+
+
 def always_excluded(name):
     """Directory name in _ALWAYS_EXCLUDE, entries may be globs (e.g. *.egg-info)."""
     folded = name.casefold()
@@ -122,10 +177,12 @@ def _top_level_dirs(root):
         names = os.listdir(root)
     except OSError:
         return []
+    skipped = mechanical_excludes(root)
     return sorted(
         name for name in names
         if not name.startswith(".")
         and not always_excluded(name)
+        and name not in skipped
         and os.path.isdir(os.path.join(root, name))
         and _within_root(root, os.path.join(root, name))
     )
@@ -293,7 +350,8 @@ def _build_scope_prompt(root, ambiguous_dirs, root_files, doc_context):
         "You are deciding what to include in a semantic code-search index for the "
         f"repository at {root}.\n\n"
         "These directories are already excluded automatically (dependency/tooling caches "
-        f"whose meaning does not vary by project): {', '.join(sorted(_ALWAYS_EXCLUDE))}. "
+        f"whose meaning does not vary by project): {', '.join(sorted({*_ALWAYS_EXCLUDE, *mechanical_excludes(root)}))}. "
+        "Every hidden folder (name starting with a dot: .git, .vscode, .crowd, .tokenguard...) is also never indexed. "
         "Do not decide on them.\n\n"
         f"Directories that still need a decision: {', '.join(ambiguous_dirs) or '(none)'}\n\n"
         "Loose files at the repository ROOT are indexed automatically, because in a flat "
@@ -317,6 +375,8 @@ def _build_scope_prompt(root, ambiguous_dirs, root_files, doc_context):
         "source, even if it also contains a few generated/log files. Only call submit_scope "
         "once every non-obvious directory is grounded in inspection data or in the "
         "documentation.\n\n"
+        "`include` lists folder paths relative to the root, without wildcards; a folder you leave out of `include` is "
+        "not indexed, and an empty `include` indexes only the loose root files. "
         "Include sources useful for search even if they are gitignored (e.g. docs/, README, "
         "ADRs). Java, Angular, HTML/CSS, plain text and Markdown are supported sources. "
         "DOCX documents are supported through bounded local text extraction; do not exclude "
@@ -333,7 +393,7 @@ def decide_scope(root, router_model, force=False, deadline=None, cancel_check=No
         return cached
 
     top_level_dirs = _top_level_dirs(root)
-    ambiguous_dirs = [d for d in top_level_dirs if not always_excluded(d) and d not in tool_state_excludes(root)]
+    ambiguous_dirs = list(top_level_dirs)
     root_files = _root_level_files(root, _exclude_matcher(_ALWAYS_EXCLUDE_FILES))
     doc_context = _read_root_docs(root)
 
@@ -392,11 +452,13 @@ def decide_scope(root, router_model, force=False, deadline=None, cancel_check=No
 
     if decision is None:
         raise RuntimeError("The model did not define a valid scope. Check the model or set the scope manually.")
-    final = {"include": (decision or {}).get("include") or [],
-             "exclude": [*((decision or {}).get("exclude") or []), *tool_state_excludes(root)],
+    include, dropped = normalize_include(decision.get("include"))
+    final = {"include": include,
+             "exclude": [*(decision.get("exclude") or []), *mechanical_excludes(root)],
              "user_exclude": (cached or {}).get("user_exclude", [])}
     scope = {
         "include": final["include"],
+        "dropped_include": [str(item) for item in dropped],
         "exclude": final["exclude"],
         "top_level_dirs": top_level_dirs,
         "scope_version": SCOPE_VERSION,
@@ -422,7 +484,7 @@ def _root_level_files(root, matcher):
         raise OSError("Could not list the root; the existing index was kept.") from exc
     out = []
     for name in names:
-        if matcher(name):
+        if matcher(name) or name.startswith("."):
             continue
         full = os.path.join(root, name)
         # `isfile` segue link: sem a checagem de contenção, um link na raiz apontando
@@ -466,16 +528,15 @@ def scope_filter(scope, root=None):
     """Predicate `keep(rel_path)`: whether resolve_included_files would list rel_path (a file) or walk it (a folder) —
     under an include base, outside the exclusions, outside hidden folders. Built once so a burst of file events does not
     rebuild the matcher per path; `root` adds the tool-runtime folders of a known config home."""
-    include = scope.get("include") or [""]
+    bases, _dropped = normalize_include(scope.get("include"))
     matcher = _exclude_matcher(set(scope.get("exclude") or []) | set(scope.get("user_exclude") or []) |
-                               set(tool_state_excludes(root) if root else ()) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
-    bases = [base.strip("/") for base in include]
-    whole = any(base in ("", ".") for base in include)
+                               set(mechanical_excludes(root) if root else ()) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
+    whole = "" in bases
 
     def keep(rel_path):
         rel_path = rel_path.replace("\\", "/")
         parts = rel_path.split("/")
-        if matcher(rel_path) or any(part.startswith(".") for part in parts[:-1]):
+        if matcher(rel_path) or is_hidden(rel_path):
             return False
         if whole or len(parts) == 1:
             return True
@@ -493,16 +554,16 @@ def in_scope(scope, rel_path, root=None):
 def resolve_included_files(root, scope, cancel_check=None):
     if not valid_scope(scope):
         raise ValueError("Invalid scope; request a new project analysis.")
-    include = scope.get("include") or [""]
+    include, _dropped = normalize_include(scope.get("include"))
     matcher = _exclude_matcher(set(scope.get("exclude") or []) | set(scope.get("user_exclude") or []) |
-                               set(tool_state_excludes(root)) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
+                               set(mechanical_excludes(root)) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
     files = []
     def walk_error(error):
         raise OSError("Could not list a folder in the scope; try again when it is accessible.") from error
-    if not any(base in ("", ".") for base in include):
+    if "" not in include:
         files.extend(_root_level_files(root, matcher))
     for base in include:
-        base_full = os.path.join(root, base) if base not in ("", ".") else root
+        base_full = os.path.join(root, base) if base else root
         # `include` vem de tool call de um LLM cujo prompt embute documentação do
         # repositório analisado: um valor absoluto ou com `..` faria a varredura sair do
         # projeto e mandar conteúdo de fora pro endpoint de embeddings.
@@ -510,7 +571,7 @@ def resolve_included_files(root, scope, cancel_check=None):
             continue
         if os.path.isfile(base_full):
             rel = os.path.relpath(base_full, root).replace(os.sep, "/")
-            if not matcher(rel):
+            if not matcher(rel) and not is_hidden(rel):
                 files.append(rel)
             continue
         for dirpath, dirnames, filenames in os.walk(base_full, onerror=walk_error):
@@ -528,6 +589,6 @@ def resolve_included_files(root, scope, cancel_check=None):
             ]
             for name in filenames:
                 rel_path = f"{rel_dir}/{name}" if rel_dir else name
-                if not matcher(rel_path) and _within_root(root, os.path.join(root, rel_path)):
+                if not name.startswith(".") and not matcher(rel_path) and _within_root(root, os.path.join(root, rel_path)):
                     files.append(rel_path)
     return sorted(set(files))

package/install_runtime.py

@@ -21,6 +21,8 @@ import venv
 import zipfile
 from pathlib import Path
 
+import node_locator
+
 
 ROOT = Path(__file__).resolve().parent
 NODE_DIR = ROOT / "web_adapters" / "node"
@@ -32,7 +34,7 @@ JAVA_PARSER = NODE_DIR / 'node_modules' / 'java-parser' / 'src' / 'index.js'
 ANGULAR_PARSER = NODE_DIR / 'node_modules' / '@angular' / 'compiler' / 'fesm2022' / 'compiler.mjs'
 # Browser control for agents (browser_control.py): Microsoft's Playwright MCP over the Chromium installed below.
 PLAYWRIGHT_MCP_CLI = NODE_DIR / "node_modules" / "@playwright" / "mcp" / "cli.js"
-NODE_RUNTIME = NODE_DIR / ".node-runtime"
+NODE_RUNTIME = Path(node_locator.LOCAL_RUNTIME)
 # Moli renders the JavaScript pages web_fetch cannot read over HTTP; Chromium (Crawl4AI) stays as its fallback.
 # Measured on 2026-10-10 over 21 such pages: 1.6 s and 90 MB peak (median) against 4.2 s and 581 MB for Chromium.
 MOLI_VERSION = "1.1.15"
@@ -58,14 +60,16 @@ def _node_supported(node):
 
 
 def _node_commands():
+    """(node, npm) of the Node to use: the machine's, found through the PATH first, else the one inside Smart Tool;
+    (None, None) when neither is a supported version."""
+    node = node_locator.which("node")
+    npm = node_locator.which("npm.cmd") or node_locator.which("npm")
+    if node and npm and _node_supported(node):
+        return node, npm
     local_node, local_npm = NODE_RUNTIME / "node.exe", NODE_RUNTIME / "npm.cmd"
-    if NODE_RUNTIME.exists():
-        if local_node.is_file() and local_npm.is_file() and _node_supported(local_node):
-            return str(local_node), str(local_npm)
-        return None, None
-    node = shutil.which("node")
-    npm = shutil.which("npm.cmd") or shutil.which("npm")
-    return (node, npm) if node and npm and _node_supported(node) else (None, None)
+    if local_node.is_file() and local_npm.is_file() and _node_supported(local_node):
+        return str(local_node), str(local_npm)
+    return None, None
 
 
 def _download_verified(url, expected_sha256, path):
@@ -169,10 +173,9 @@ def _install_moli():
 def _run(args, *, cwd=None, label="Web dependency", idle_s=600, stream=False, attempts=1):
     """Runs a step with UTF-8 output and closed stdin (a prompt fails at once instead of hanging); it is stopped only
     after idle_s without any output, and stream shows the output live."""
-    env = os.environ.copy()
+    node, _npm = _node_commands()
+    env = node_locator.environment(prefer=node)
     env.update(PYTHONUTF8="1", PYTHONIOENCODING="utf-8")
-    if NODE_RUNTIME.is_dir():
-        env["PATH"] = str(NODE_RUNTIME) + os.pathsep + env.get("PATH", "")
     flags = (subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW) if os.name == "nt" else 0
     for attempt in range(1, attempts + 1):
         print(f"{label}: starting{f' (attempt {attempt} of {attempts})' if attempt > 1 else ''}...", flush=True)

package/node_locator.py

@@ -0,0 +1,103 @@
+"""Where Node.js (and npx/npm) is on this machine, looked up when it is needed and never remembered.
+
+A process keeps the PATH it was born with: the tray started at logon never sees a Node installed, moved or removed
+afterwards, and everything it launches (the updater, the installer, the daemon) inherits that stale PATH. The lookup is
+therefore: the process PATH, then the PATH Windows stores for the machine and the user (what a new process would get),
+then the usual install folders. The Node that Smart Tool downloads into web_adapters/node/.node-runtime is the last
+resort of `node()`, used only when the machine has none.
+"""
+import os
+import shutil
+
+LOCAL_RUNTIME = os.path.join(os.path.dirname(os.path.abspath(__file__)), "web_adapters", "node", ".node-runtime")
+_MACHINE_ENVIRONMENT = r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
+
+
+def _registry_path():
+    """Entries of the machine and user PATH as stored in the registry, variables expanded."""
+    if os.name != "nt":
+        return []
+    import winreg
+    entries = []
+    for hive, subkey in ((winreg.HKEY_LOCAL_MACHINE, _MACHINE_ENVIRONMENT), (winreg.HKEY_CURRENT_USER, "Environment")):
+        try:
+            with winreg.OpenKey(hive, subkey) as key:
+                entries += os.path.expandvars(winreg.QueryValueEx(key, "Path")[0]).split(os.pathsep)
+        except FileNotFoundError:
+            continue
+    return entries
+
+
+def _unique(entries):
+    seen, kept = set(), []
+    for entry in entries:
+        entry = entry.strip().strip('"')
+        if entry and os.path.normcase(entry) not in seen:
+            seen.add(os.path.normcase(entry))
+            kept.append(entry)
+    return kept
+
+
+def search_path():
+    """The process PATH followed by the registry PATH entries it does not have."""
+    return _unique(os.environ.get("PATH", "").split(os.pathsep) + _registry_path())
+
+
+def known_folders():
+    """Where Node installers and version managers put node.exe, for a machine whose PATH does not list it."""
+    program_files = [os.environ.get(name) for name in ("ProgramFiles", "ProgramW6432", "ProgramFiles(x86)")]
+    local = os.environ.get("LOCALAPPDATA")
+    home = os.path.expanduser("~")
+    candidates = [os.path.join(base, "nodejs") for base in program_files if base]
+    candidates += [os.environ.get("NVM_SYMLINK"), os.environ.get("FNM_MULTISHELL_PATH"),
+                   os.path.join(os.environ["VOLTA_HOME"], "bin") if os.environ.get("VOLTA_HOME") else None,
+                   os.path.join(local, "Programs", "nodejs") if local else None,
+                   os.path.join(home, "scoop", "apps", "nodejs", "current"),
+                   os.path.join(home, "scoop", "apps", "nodejs-lts", "current"),
+                   os.path.join(os.environ["ChocolateyInstall"], "bin") if os.environ.get("ChocolateyInstall") else None]
+    return _unique(path for path in candidates if path)
+
+
+_FOUND = {}
+
+
+def which(name):
+    """Full path of an executable (`node`, `npx.cmd`...): the PATH first, the known install folders only when the PATH
+    does not have it; None when neither does. A path found is remembered per PATH value and used again only while the
+    file is still there, so a lookup costs a stat, not a scan of every folder, and a moved Node is searched again."""
+    key = (name, os.environ.get("PATH", ""))
+    found = _FOUND.get(key)
+    if found and os.path.isfile(found):
+        return found
+    found = (shutil.which(name, path=os.pathsep.join(search_path()))
+             or shutil.which(name, path=os.pathsep.join(known_folders())))
+    if found:
+        _FOUND[key] = found
+    return found
+
+
+def local_node():
+    """The Node downloaded into Smart Tool, or None."""
+    path = os.path.join(LOCAL_RUNTIME, "node.exe")
+    return path if os.path.isfile(path) else None
+
+
+def node():
+    """node.exe of the machine (PATH first), else the Node inside Smart Tool, else None."""
+    return which("node") or local_node()
+
+
+def environment(prefer=None):
+    """A copy of the environment with the current PATH (see search_path), the folder of `prefer` (an executable)
+    first: what a process launched now should inherit."""
+    env = {key: value for key, value in os.environ.items() if key.upper() != "PATH"}
+    entries = search_path()
+    if prefer:
+        entries.insert(0, os.path.dirname(prefer))
+    env["PATH"] = os.pathsep.join(_unique(entries))
+    return env
+
+
+def exists(command):
+    """Whether a registered executable (a full path, or a bare name resolved through the PATH) is still there."""
+    return os.path.isfile(command) or bool(which(command))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.26",
+  "version": "0.9.28",
   "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/smart_tool_daemon.py

@@ -40,6 +40,7 @@ import capabilities
 import client_hooks
 import install_runtime
 import integration_metrics
+import node_locator
 import config
 import freshness
 import model_client
@@ -892,11 +893,11 @@ def _cold_index(root, cfg, problem):
 
 
 def _cold_overlay(root, queries):
-    """`(overlay, warning)` for a project with no index: the in-scope files (the saved scope, else the whole folder minus
-    the always-excluded names) holding a query term, read from disk and ranked by keyword, plus the notice that the
-    index is being built. The scan stops after `COLD_SCAN_BUDGET_S`."""
+    """`(overlay, warning)` for a project with no index: the in-scope files (the saved scope, else only the loose files
+    at the root: no folder is read before it is classified) holding a query term, read from disk and ranked by
+    keyword, plus the notice that the index is being built. The scan stops after `COLD_SCAN_BUDGET_S`."""
     scope = index_scope.load_scope(root)
-    files = index_scope.resolve_included_files(root, scope if index_scope.valid_scope(scope) else {"include": [""]})
+    files = index_scope.resolve_included_files(root, scope if index_scope.valid_scope(scope) else {"include": []})
     chunks, scanned = indexer.keyword_chunks(root, files, queries, COLD_SCAN_BUDGET_S)
     reached = f"{scanned} of {len(files)} files" if scanned < len(files) else f"all {len(files)} files"
     warning = ("Indexing in progress: this folder has no index yet, so the results are keyword matches read straight "
@@ -1958,7 +1959,10 @@ def _project_action_locked(arguments):
         manual = arguments.get("manual", True)
         if type(manual) is not bool:
             raise ValueError("manual must be true or false.")
-        scope = dict(index_scope.load_scope(project["root"]) or {"include": ["."], "exclude": []})
+        scope = dict(index_scope.load_scope(project["root"]) or {"include": [], "exclude": []})
+        if "include" not in arguments and not scope.get("include"):
+            raise ValueError("include is required: list the folders with the project's code, tests and docs. "
+                             "Nothing is indexed from a folder that is not listed.")
         for field in ("include", "exclude", "user_exclude"):
             values = arguments.get(field, scope.get(field, []))
             if not isinstance(values, list) or len(values) > 200 or any(
@@ -1969,6 +1973,10 @@ def _project_action_locked(arguments):
                     raise ValueError("The scope must stay inside the project folder.")
                 if field == "include" and not project_identity.within_root(project["root"], os.path.join(project["root"], value)):
                     raise ValueError("Include points outside the folder.")
+                if field == "include" and index_scope.is_hidden(value):
+                    raise ValueError(f"Include '{value}' is inside a hidden folder: hidden folders are never indexed.")
+            if field == "include":
+                values = index_scope.normalize_include(values)[0]
             scope[field] = values
         scope.update(manual=manual, scope_version=index_scope.SCOPE_VERSION if manual else 0)
         scope.pop("profile", None)
@@ -2071,9 +2079,9 @@ def _run_search_script(executable, script_path, args, timeout_s):
         if _IS_WINDOWS else {"start_new_session": True}
     )
     proc = subprocess.Popen(
-        [executable, script_path, *args],
+        [web_search_adapters.executable_path(executable), script_path, *args],
         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace",
-        env={**os.environ, "SMART_TOOL_USER_AGENT": version.user_agent(config.load_config().get("contact"))},
+        env={**node_locator.environment(), "SMART_TOOL_USER_AGENT": version.user_agent(config.load_config().get("contact"))},
         **popen_kwargs,
     )
     try:
@@ -4176,6 +4184,14 @@ def _probe_capabilities():
         _log(f"capabilities probe failed: {type(exc).__name__}: {exc}")
 
 
+def _heal_browser_control():
+    """Re-registers the Playwright MCP server when the Node it was registered with is gone (Node moved or reinstalled)."""
+    try:
+        browser_control.heal(_log)
+    except Exception as exc:
+        _log(f"browser control not refreshed: {type(exc).__name__}: {exc}")
+
+
 def main():
     global _PROJECT_MONITOR
     # O bind vem antes de qualquer I/O de rede: enquanto a porta não abre, o
@@ -4199,6 +4215,7 @@ def main():
     except (OSError, ValueError) as exc:
         _log(f"clients not pointed to port {_BOUND_PORT}: {type(exc).__name__}: {exc}")
     atexit.register(BROWSER_SERVICE.close)
+    threading.Thread(target=_heal_browser_control, daemon=True).start()
     try:
         recovered = project_store.recover_interrupted()
         project_store.import_known_legacy(indexer.INDEX_DIR)

package/update_check.py

@@ -13,6 +13,7 @@ import urllib.request
 
 import atomic_io
 import config
+import node_locator
 import paths
 import version
 
@@ -136,7 +137,9 @@ def notices(now=None):
 
 def run_update(latest, automatic):
     """Starts the install command in its own visible console, detached from the tray (the installer stops and restarts
-    the tray). The console closes on success and stays open with the error on failure."""
+    the tray). The console closes on success and stays open with the error on failure. npx is looked up now, not in the
+    PATH the tray was born with: a Node installed or moved since the last logon still runs the update, and the folder
+    found is put first in the PATH the installer (and the tray it restarts) inherits."""
     if automatic:
         state = _state()
         state.update(attempted=latest, at=time.time())
@@ -144,4 +147,4 @@ def run_update(latest, automatic):
     flags = getattr(subprocess, "CREATE_NEW_CONSOLE", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
     command = f'title Smart Tool update to {latest} && {UPDATE_COMMAND} || pause'
     subprocess.Popen(["cmd.exe", "/c", command], creationflags=flags, close_fds=True,
-                     cwd=os.path.expanduser("~"))
+                     cwd=os.path.expanduser("~"), env=node_locator.environment(prefer=node_locator.which("npx.cmd")))

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

package/web_search_adapters.py

@@ -31,11 +31,14 @@ Bing entra pelo tier yahoo.
 import os
 import sys
 
+import node_locator
+
 PACKAGE_DIR = os.path.dirname(os.path.abspath(__file__))
 NODE_ADAPTER_DIR = os.path.join(PACKAGE_DIR, "web_adapters", "node")
 BROWSER_ADAPTER_DIR = os.path.join(PACKAGE_DIR, "web_adapters", "browser")
-LOCAL_NODE_EXECUTABLE = os.path.join(NODE_ADAPTER_DIR, ".node-runtime", "node.exe")
-NODE_EXECUTABLE = LOCAL_NODE_EXECUTABLE if os.path.isfile(LOCAL_NODE_EXECUTABLE) else "node"
+# Adapters name Node, not a path: `executable_path` finds it when the adapter is launched (node_locator), so a Node
+# installed, moved or removed while the daemon runs is followed without a restart.
+NODE_EXECUTABLE = "node"
 CAMOUFOX_VENV_PYTHON = os.path.join(BROWSER_ADAPTER_DIR, ".venv", "Scripts", "python.exe")
 BROWSER_SERVICE_SCRIPT = os.path.join(BROWSER_ADAPTER_DIR, "browser_service.py")
 DDG_SEARCH_SCRIPT = os.path.join(NODE_ADAPTER_DIR, "ddg-search.mjs")
@@ -44,6 +47,13 @@ WIKIPEDIA_SEARCH_SCRIPT = os.path.join(NODE_ADAPTER_DIR, "wikipedia-search.mjs")
 EXTERNAL_SEARCH_SCRIPT = os.path.join(PACKAGE_DIR, "web_search_external.py")
 DDGS_SEARCH_SCRIPT = os.path.join(PACKAGE_DIR, "web_search_ddgs.py")
 
+
+def executable_path(executable):
+    """The program to launch for an adapter's `executable`: Node is looked up now (PATH first, then the Node inside
+    Smart Tool); any other executable is returned unchanged. A Node that is nowhere stays `node`, so the launch fails
+    with the system's own "not found"."""
+    return (node_locator.node() or NODE_EXECUTABLE) if executable == NODE_EXECUTABLE else executable
+
 FETCH_TIMEOUT_S = 15
 OPEN_WEBSEARCH_TIMEOUT_S = 30
 WIKIPEDIA_TIMEOUT_S = 15