@allansantos-dev/smart-tool 0.9.5 → 0.9.7

package/smart_tool_daemon.py

@@ -169,6 +169,10 @@ _jobs = {}
 _JOBS_LOCK = threading.Lock()
 _MAX_JOBS_RETAINED = 200
 SMART_SEARCH_SYNC_WAIT_S = 3
+# smart_search_result waits for the job this long before answering pending: answering at once had an agent poll the
+# same job 7 times in 16 s and then give up on Smart Tool (claude -p session, 2026-10-09; job durations median 6 s,
+# p75 10.7 s).
+SMART_SEARCH_RESULT_WAIT_S = 15
 SMART_SEARCH_MAX_PENDING = 8
 SMART_SEARCH_EXECUTOR = project_scheduler.ProjectScheduler(workers=3)
 _PROJECT_LOCKS = {}
@@ -300,6 +304,20 @@ def _smart_search_job_payload(job_id):
         payload['view'] = job['view']
     return payload
 
+# Claude Code defers MCP tools behind tool search; the tools the hook redirects to (and their job polling) load
+# upfront, so a blocked agent already has the replacement in its tool list.
+ALWAYS_LOAD = {"anthropic/alwaysLoad": True}
+SERVER_INSTRUCTIONS = (
+    "Smart Tool serves an indexed semantic search over the user's projects and a cheaper web reader. The user installed "
+    "a PreToolUse hook that blocks content searches over a project folder (grep -r, rg, git grep, Grep on a folder) "
+    "and native WebFetch/WebSearch. A call blocked by Smart Tool is a routing rule, not a failure: make the call the block "
+    "message names (smart_search with project_root and query_identifiers, web_fetch with url and prompt, web_search "
+    "with query). Never retry the same search or download through Bash, python, node, PowerShell, curl or wget: that "
+    "bypasses the rule the user set. Reading one known file, or searching inside one known file, is never blocked. "
+    "Before changing a function, project_manage action=graph with symbol lists its callers and tests; after editing, "
+    "project_manage action=affected_tests lists the tests to run."
+)
+
 TOOLS = [
     {
         "name": "project_manage",
@@ -339,6 +357,7 @@ TOOLS = [
     },
     {
         "name": "smart_search",
+        "_meta": ALWAYS_LOAD,
         "description": (
             "Semantic search (embed+rerank) over the project's index. Use instead of "
             "raw grep/read when the search has no clear scope (e.g. a folder with node_modules). "
@@ -372,6 +391,7 @@ TOOLS = [
     },
     {
         "name": "smart_search_result",
+        "_meta": ALWAYS_LOAD,
         "description": (
             "Checks the progress and result of a background smart_search. "
             "Pass the job_id returned by smart_search; while pending, wait retry_after_s and check again."
@@ -386,6 +406,7 @@ TOOLS = [
     },
     {
         "name": "web_search",
+        "_meta": ALWAYS_LOAD,
         "description": (
             "Web search with curated results (title/url/snippet) - use instead of "
             "the native WebSearch: several sources in parallel, the query in two languages and a cache shared across sessions. Starts with free HTTP "
@@ -433,6 +454,7 @@ TOOLS = [
     },
     {
         "name": "web_fetch",
+        "_meta": ALWAYS_LOAD,
         "description": (
             "Reads a known URL and returns only the answer to the prompt, written by the gateway's mini model - use instead of "
             "the native WebFetch. The page is cached for 24 h: another prompt on the same URL does not download it again. "
@@ -449,6 +471,7 @@ TOOLS = [
     },
     {
         "name": "web_search_result",
+        "_meta": ALWAYS_LOAD,
         "description": (
             "Checks the status/result of a deep research job "
             "(web_search with depth='deep' or depth='research')."
@@ -788,6 +811,11 @@ def _prepare_project_index(arguments, job_id, cfg, token, query_vector=None, pre
     checkpoint()
     _update_job(job_id, phase="scope")
     scope = index_scope.load_scope(root)
+    if scope is None and not arguments.get("force_scope"):
+        inherited = index_scope.sibling_scope(root)
+        if inherited is not None and not index_scope.needs_rescan(root, inherited):
+            index_scope.save_scope(root, inherited)
+            scope = inherited
     scope_model = cfg.get("scope_model") or cfg.get("router_model")
     if arguments.get("force_scope") or (project.get('scope_dirty') and not (scope or {}).get('manual')) or scope is None or index_scope.needs_rescan(root, scope):
         problem = _gateway_problem() if scope_model else None
@@ -1323,6 +1351,10 @@ def _handle_smart_search_result(arguments):
     if not job_id:
         raise ValueError("smart_search_result requires 'job_id'")
     payload = _smart_search_job_payload(job_id)
+    deadline = time.monotonic() + SMART_SEARCH_RESULT_WAIT_S
+    while payload["status"] == "pending" and time.monotonic() < deadline:
+        time.sleep(0.25)
+        payload = _smart_search_job_payload(job_id)
     _mark_notice_delivered(job_id)
     return _to_json_sanitized(payload)
 
@@ -3243,10 +3275,9 @@ def _web_route(tool, url):
     if problem:
         return {"redirect": False, "reason": f"gateway unavailable: {problem}"}
     if tool == "WebFetch":
-        return {"redirect": True, "reason": "Use the web_fetch tool from the smart-tool MCP (url + prompt): the mini model reads "
-                "the page, the answer comes back short and the page is cached for 24 h."}
-    return {"redirect": True, "reason": "Use the web_search tool from the smart-tool MCP (query + query_en): several sources, "
-            "two languages and a cache shared across sessions."}
+        return {"redirect": True, "reason": "the mini model reads the page, the answer comes back short and the page is "
+                "cached for 24 h."}
+    return {"redirect": True, "reason": "several sources, two languages and a cache shared across sessions."}
 
 
 HOOK_MAX_BODY_BYTES = 4 * 1024 * 1024
@@ -3330,6 +3361,7 @@ def _dispatch(method, params, session_id):
             "protocolVersion": PROTOCOL_VERSION,
             "capabilities": {"tools": {}},
             "serverInfo": {"name": "smart-tool", "version": version.VERSION},
+            "instructions": SERVER_INSTRUCTIONS,
         }
     if method == "tools/list":
         return {"tools": TOOLS}

package/tray.py

@@ -20,8 +20,10 @@ import pystray
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import autostart
+import config
 import daemon_launcher
 import update_check
+import version
 
 POLL_INTERVAL_S = 45
 UPDATE_CHECK_INTERVAL_S = 24 * 3600
@@ -110,6 +112,9 @@ def _poll_loop(icon):
 
 
 def _update_loop(icon):
+    """Checks npm at start and every 24 h. At start (logon, before agent sessions use the daemon) a newer version is
+    installed right away when auto_update is on; later checks only notify and offer it in the menu."""
+    first = True
     while True:
         try:
             latest = update_check.newer_version()
@@ -118,19 +123,56 @@ def _update_loop(icon):
         if latest and latest != _state["update"]:
             _state["update"] = latest
             icon.update_menu()
-            icon.notify(f"Smart Tool {latest} is available. Update with: {update_check.UPDATE_COMMAND}", "Smart Tool")
+            if first and config.auto_update() and update_check.should_auto_update(latest):
+                icon.notify(f"Updating Smart Tool to {latest}...", "Smart Tool")
+                update_check.run_update(latest, automatic=True)
+            else:
+                icon.notify(f"Smart Tool {latest} is available: use \"Update to {latest}\" in this menu.", "Smart Tool")
+        first = False
         time.sleep(UPDATE_CHECK_INTERVAL_S)
 
 
 def _update_label(item):
-    return f"Update to {_state['update']} (copy command)"
+    return f"Update to {_state['update']}" if _state["update"] else "Check for updates"
+
+
+_update_busy = threading.Lock()
+
+
+def _update_now(icon, item):
+    """Menu action: installs the known newer version, or checks npm first and says when there is none."""
+    if not _update_busy.acquire(blocking=False):
+        return
+
+    def run():
+        try:
+            latest = _state["update"] or update_check.newer_version()
+            if not latest:
+                icon.notify(f"Smart Tool {version.VERSION} is the latest version.", "Smart Tool")
+                return
+            _state["update"] = latest
+            icon.update_menu()
+            update_check.run_update(latest, automatic=False)
+        except Exception as exc:
+            icon.notify(f"Could not update: {exc}", "Smart Tool")
+        finally:
+            _update_busy.release()
+    threading.Thread(target=run, daemon=True).start()
+
 
+def _auto_update_checked(item):
+    try:
+        return config.auto_update()
+    except Exception:
+        return False
 
-def _copy_update_command(icon, item):
-    import subprocess
-    subprocess.run(["clip.exe"], input=update_check.UPDATE_COMMAND.encode("ascii"), check=True,
-                   creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
-    icon.notify(f"Copied: {update_check.UPDATE_COMMAND}. Paste it in a terminal.", "Smart Tool")
+
+def _toggle_auto_update(icon, item):
+    try:
+        config.update_config(lambda cfg: cfg.__setitem__("auto_update", not config.auto_update(cfg)))
+    except Exception as exc:
+        icon.notify(f"Could not change automatic updates: {exc}", "Smart Tool")
+    icon.update_menu()
 
 
 def _open_setup(icon, item):
@@ -227,7 +269,8 @@ def main():
             pystray.MenuItem("Index a folder…", _add_project),
             pystray.MenuItem("Open settings", _open_setup),
             pystray.MenuItem("Start with Windows", _toggle_autostart, checked=_autostart_checked),
-            pystray.MenuItem(_update_label, _copy_update_command, visible=lambda item: bool(_state["update"])),
+            pystray.MenuItem(_update_label, _update_now),
+            pystray.MenuItem("Update automatically", _toggle_auto_update, checked=_auto_update_checked),
             pystray.MenuItem("Quit", _quit),
         ),
     )

package/update_check.py

@@ -1,12 +1,19 @@
-"""Newer Smart Tool release on npm, for the tray notice. Updating is running the install command again."""
+"""Newer Smart Tool release on npm and the update itself: the tray runs the same install command a user would, in a
+visible console, at startup (once per version, when auto_update is on) or on demand from its menu."""
 import json
+import os
+import subprocess
+import time
 import urllib.request
 
+import atomic_io
+import paths
 import version
 
 PACKAGE = "@allansantos-dev/smart-tool"
 REGISTRY_URL = "https://registry.npmjs.org/@allansantos-dev%2Fsmart-tool/latest"
-UPDATE_COMMAND = f"npx {PACKAGE}@latest install"
+UPDATE_COMMAND = f"npx --yes {PACKAGE}@latest install"
+STATE_PATH = os.path.join(paths.DATA_DIR, "update-state.json")
 
 
 def _parts(value):
@@ -20,3 +27,30 @@ def newer_version(timeout=10):
     with urllib.request.urlopen(request, timeout=timeout) as response:
         latest = json.load(response)["version"]
     return latest if _parts(latest) > _parts(version.VERSION) else None
+
+
+def attempted():
+    """Version the last automatic update went for, or None."""
+    try:
+        with open(STATE_PATH, encoding="utf-8") as stream:
+            return json.load(stream).get("attempted")
+    except FileNotFoundError:
+        return None
+
+
+def should_auto_update(latest):
+    """An automatic update runs once per version: when it fails, the installer restores the previous version and
+    restarts the tray, which would otherwise try the same version again on every start."""
+    return bool(latest) and attempted() != latest
+
+
+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."""
+    if automatic:
+        os.makedirs(os.path.dirname(STATE_PATH), exist_ok=True)
+        atomic_io.write_secret_text(STATE_PATH, json.dumps({"attempted": latest, "at": time.time()}))
+    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("~"))

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