@allansantos-dev/smart-tool 0.9.0 → 0.9.2

package/local_embedder.py

@@ -1,172 +1,172 @@
-"""Embedder local do mcp-memory (sidecar granite em ~/.mcp-memory/embedding.properties) como reserva sem modelo no gateway.
-
-Medido em 2026-10-05 no gabarito do rerank (42 alvos de código, sem rerank, docs/spikes/local_embedder_spike.py):
-granite-embedding-107m-multilingual local 42/35/41 (no pool / 1º / top 5), MRR@5 0,892; gateway
-text-embedding-3-small do gateway 42/35/40, 0,885; só lexical 38/29/36, 0,767.
-"""
-import http.client
-import json
-import os
-import threading
-import time
-import urllib.parse
-
-import config
-import indexer
-
-PREFIX = "local:"
-PROPERTIES = os.path.join(os.path.expanduser("~"), ".mcp-memory", "embedding.properties")
-BATCH = 16
-INFO_TTL_S = 60
-MAX_ATTEMPTS = 3
-REQUEST_TIMEOUT_S = 60
-_lock = threading.Lock()
-_info = {"at": 0.0, "value": None}
-
-
-def url():
-    """Sidecar base URL; None when absent or `tei.url=off`. localhost becomes 127.0.0.1: on Windows ::1 is tried
-    first and a sidecar bound to IPv4 only costs ~2 s per connection (measured)."""
-    try:
-        with open(PROPERTIES, encoding="utf-8") as stream:
-            for line in stream:
-                key, _, value = line.strip().partition("=")
-                value = value.strip()
-                if key.strip() == "tei.url":
-                    if not value or value.lower() == "off":
-                        return None
-                    parsed = urllib.parse.urlsplit(value.rstrip("/"))
-                    if parsed.hostname == "localhost":
-                        parsed = parsed._replace(netloc=parsed.netloc.replace("localhost", "127.0.0.1", 1))
-                    return urllib.parse.urlunsplit(parsed)
-    except OSError:
-        return None
-    return None
-
-
-def configured():
-    return url() is not None
-
-
-def _connection(base, timeout):
-    parsed = urllib.parse.urlsplit(base)
-    cls = http.client.HTTPSConnection if parsed.scheme == "https" else http.client.HTTPConnection
-    return cls(parsed.hostname, parsed.port, timeout=timeout)
-
-
-def _request(conn, method, path, body=None):
-    headers = {"Content-Type": "application/json"} if body is not None else {}
-    conn.request(method, path, body=json.dumps(body).encode("utf-8") if body is not None else None, headers=headers)
-    response = conn.getresponse()
-    data = response.read()
-    if response.status >= 400:
-        raise ConnectionError(f"local embedder answered HTTP {response.status}")
-    return json.loads(data)
-
-
-def _probe(base, timeout):
-    conn = _connection(base, timeout)
-    try:
-        data = _request(conn, "GET", "/info")
-    finally:
-        conn.close()
-    if not data.get("model_id") or int(data.get("dimension") or 0) <= 0:
-        raise ValueError("local embedder has no model_id/dimension in /info")
-    return {"model": PREFIX + data["model_id"], "dimensions": int(data["dimension"]), "url": base,
-            "sha256": data.get("model_sha256")}
-
-
-def info(timeout=1.5):
-    """Sidecar /info cached for INFO_TTL_S; None when not configured or not answering. The probe runs under the lock
-    so a slow failing probe never overwrites a newer good answer."""
-    with _lock:
-        if time.monotonic() - _info["at"] < INFO_TTL_S:
-            return _info["value"]
-        base, value = url(), None
-        if base:
-            try:
-                value = _probe(base, timeout)
-            except (OSError, ValueError, http.client.HTTPException):
-                value = None
-        _info.update(at=time.monotonic(), value=value)
-        return value
-
-
-def is_local(model):
-    return bool(model) and model.startswith(PREFIX)
-
-
-def resolve(configured_model, current=None, mode=None):
-    """Embedding model for the index, following config `local_models` (fallback | off | prefer).
-
-    An index already built with the local model is kept while the sidecar is briefly down, so a restart of the
-    sidecar never triggers a rebuild to lexical and back."""
-    mode = mode or config.local_models_mode()
-    if mode == "off":
-        return configured_model or indexer.LEXICAL_MODEL
-    if configured_model and mode == "fallback":
-        return configured_model
-    available = info()
-    if available:
-        return available["model"]
-    if is_local(current):
-        return current
-    return configured_model or indexer.LEXICAL_MODEL
-
-
-def _left(deadline):
-    if deadline is None:
-        return REQUEST_TIMEOUT_S
-    left = deadline - time.monotonic()
-    if left <= 0:
-        raise TimeoutError("Deadline exceeded before local embeddings finished.")
-    return min(REQUEST_TIMEOUT_S, left)
-
-
-def embed(model, texts, deadline=None, cancel_check=None, on_retry=None):
-    base = url()
-    if not base:
-        raise RuntimeError(f"mcp-memory local embedder is not configured ({PROPERTIES}).")
-    # Fresh /info before and after: /embed does not echo the model, and a cached answer could let vectors of a
-    # different model reach the persistent vector cache under this model's contract.
-    try:
-        before = _probe(base, _left(deadline))
-    except (OSError, ValueError, http.client.HTTPException) as exc:
-        raise RuntimeError(f"mcp-memory local embedder is not responding ({base}): {exc}") from None
-    if before["model"] != model:
-        raise indexer.IndexCompatibilityError(
-            f"The local embedder is now {before['model']}; the index was built with {model} and must be rebuilt.")
-    vectors = []
-    conn = _connection(base, _left(deadline))
-    try:
-        for start in range(0, len(texts), BATCH):
-            part = texts[start:start + BATCH]
-            for attempt in range(1, MAX_ATTEMPTS + 1):
-                if cancel_check:
-                    cancel_check()
-                conn.timeout = _left(deadline)
-                try:
-                    got = _request(conn, "POST", "/embed", {"inputs": part})
-                    break
-                except (OSError, http.client.HTTPException) as exc:
-                    conn.close()
-                    conn = _connection(base, _left(deadline))
-                    if attempt == MAX_ATTEMPTS:
-                        raise RuntimeError(f"Local embedder failed after {MAX_ATTEMPTS} attempts: {exc}") from None
-                    if on_retry:
-                        on_retry(attempt + 1, len(part))
-                    delay = attempt
-                    if deadline is not None and time.monotonic() + delay >= deadline:
-                        raise TimeoutError("Not enough time left to retry the local embedder.") from None
-                    time.sleep(delay)
-            if not isinstance(got, list) or len(got) != len(part):
-                raise indexer.IndexVectorError("Local embedder returned a vector count different from the input.")
-            for vector in got:
-                indexer.validate_vector(vector, before["dimensions"])
-            vectors += got
-    finally:
-        conn.close()
-    after = _probe(base, _left(deadline))
-    if (after["model"], after.get("sha256")) != (before["model"], before.get("sha256")):
-        raise indexer.IndexCompatibilityError("The local embedder changed models during the call; try again.")
-    return vectors
+"""Embedder local do mcp-memory (sidecar granite em ~/.mcp-memory/embedding.properties) como reserva sem modelo no gateway.
+
+Medido em 2026-10-05 no gabarito do rerank (42 alvos de código, sem rerank, docs/spikes/local_embedder_spike.py):
+granite-embedding-107m-multilingual local 42/35/41 (no pool / 1º / top 5), MRR@5 0,892; gateway
+text-embedding-3-small do gateway 42/35/40, 0,885; só lexical 38/29/36, 0,767.
+"""
+import http.client
+import json
+import os
+import threading
+import time
+import urllib.parse
+
+import config
+import indexer
+
+PREFIX = "local:"
+PROPERTIES = os.path.join(os.path.expanduser("~"), ".mcp-memory", "embedding.properties")
+BATCH = 16
+INFO_TTL_S = 60
+MAX_ATTEMPTS = 3
+REQUEST_TIMEOUT_S = 60
+_lock = threading.Lock()
+_info = {"at": 0.0, "value": None}
+
+
+def url():
+    """Sidecar base URL; None when absent or `tei.url=off`. localhost becomes 127.0.0.1: on Windows ::1 is tried
+    first and a sidecar bound to IPv4 only costs ~2 s per connection (measured)."""
+    try:
+        with open(PROPERTIES, encoding="utf-8") as stream:
+            for line in stream:
+                key, _, value = line.strip().partition("=")
+                value = value.strip()
+                if key.strip() == "tei.url":
+                    if not value or value.lower() == "off":
+                        return None
+                    parsed = urllib.parse.urlsplit(value.rstrip("/"))
+                    if parsed.hostname == "localhost":
+                        parsed = parsed._replace(netloc=parsed.netloc.replace("localhost", "127.0.0.1", 1))
+                    return urllib.parse.urlunsplit(parsed)
+    except OSError:
+        return None
+    return None
+
+
+def configured():
+    return url() is not None
+
+
+def _connection(base, timeout):
+    parsed = urllib.parse.urlsplit(base)
+    cls = http.client.HTTPSConnection if parsed.scheme == "https" else http.client.HTTPConnection
+    return cls(parsed.hostname, parsed.port, timeout=timeout)
+
+
+def _request(conn, method, path, body=None):
+    headers = {"Content-Type": "application/json"} if body is not None else {}
+    conn.request(method, path, body=json.dumps(body).encode("utf-8") if body is not None else None, headers=headers)
+    response = conn.getresponse()
+    data = response.read()
+    if response.status >= 400:
+        raise ConnectionError(f"local embedder answered HTTP {response.status}")
+    return json.loads(data)
+
+
+def _probe(base, timeout):
+    conn = _connection(base, timeout)
+    try:
+        data = _request(conn, "GET", "/info")
+    finally:
+        conn.close()
+    if not data.get("model_id") or int(data.get("dimension") or 0) <= 0:
+        raise ValueError("local embedder has no model_id/dimension in /info")
+    return {"model": PREFIX + data["model_id"], "dimensions": int(data["dimension"]), "url": base,
+            "sha256": data.get("model_sha256")}
+
+
+def info(timeout=1.5):
+    """Sidecar /info cached for INFO_TTL_S; None when not configured or not answering. The probe runs under the lock
+    so a slow failing probe never overwrites a newer good answer."""
+    with _lock:
+        if time.monotonic() - _info["at"] < INFO_TTL_S:
+            return _info["value"]
+        base, value = url(), None
+        if base:
+            try:
+                value = _probe(base, timeout)
+            except (OSError, ValueError, http.client.HTTPException):
+                value = None
+        _info.update(at=time.monotonic(), value=value)
+        return value
+
+
+def is_local(model):
+    return bool(model) and model.startswith(PREFIX)
+
+
+def resolve(configured_model, current=None, mode=None):
+    """Embedding model for the index, following config `local_models` (fallback | off | prefer).
+
+    An index already built with the local model is kept while the sidecar is briefly down, so a restart of the
+    sidecar never triggers a rebuild to lexical and back."""
+    mode = mode or config.local_models_mode()
+    if mode == "off":
+        return configured_model or indexer.LEXICAL_MODEL
+    if configured_model and mode == "fallback":
+        return configured_model
+    available = info()
+    if available:
+        return available["model"]
+    if is_local(current):
+        return current
+    return configured_model or indexer.LEXICAL_MODEL
+
+
+def _left(deadline):
+    if deadline is None:
+        return REQUEST_TIMEOUT_S
+    left = deadline - time.monotonic()
+    if left <= 0:
+        raise TimeoutError("Deadline exceeded before local embeddings finished.")
+    return min(REQUEST_TIMEOUT_S, left)
+
+
+def embed(model, texts, deadline=None, cancel_check=None, on_retry=None):
+    base = url()
+    if not base:
+        raise RuntimeError(f"mcp-memory local embedder is not configured ({PROPERTIES}).")
+    # Fresh /info before and after: /embed does not echo the model, and a cached answer could let vectors of a
+    # different model reach the persistent vector cache under this model's contract.
+    try:
+        before = _probe(base, _left(deadline))
+    except (OSError, ValueError, http.client.HTTPException) as exc:
+        raise RuntimeError(f"mcp-memory local embedder is not responding ({base}): {exc}") from None
+    if before["model"] != model:
+        raise indexer.IndexCompatibilityError(
+            f"The local embedder is now {before['model']}; the index was built with {model} and must be rebuilt.")
+    vectors = []
+    conn = _connection(base, _left(deadline))
+    try:
+        for start in range(0, len(texts), BATCH):
+            part = texts[start:start + BATCH]
+            for attempt in range(1, MAX_ATTEMPTS + 1):
+                if cancel_check:
+                    cancel_check()
+                conn.timeout = _left(deadline)
+                try:
+                    got = _request(conn, "POST", "/embed", {"inputs": part})
+                    break
+                except (OSError, http.client.HTTPException) as exc:
+                    conn.close()
+                    conn = _connection(base, _left(deadline))
+                    if attempt == MAX_ATTEMPTS:
+                        raise RuntimeError(f"Local embedder failed after {MAX_ATTEMPTS} attempts: {exc}") from None
+                    if on_retry:
+                        on_retry(attempt + 1, len(part))
+                    delay = attempt
+                    if deadline is not None and time.monotonic() + delay >= deadline:
+                        raise TimeoutError("Not enough time left to retry the local embedder.") from None
+                    time.sleep(delay)
+            if not isinstance(got, list) or len(got) != len(part):
+                raise indexer.IndexVectorError("Local embedder returned a vector count different from the input.")
+            for vector in got:
+                indexer.validate_vector(vector, before["dimensions"])
+            vectors += got
+    finally:
+        conn.close()
+    after = _probe(base, _left(deadline))
+    if (after["model"], after.get("sha256")) != (before["model"], before.get("sha256")):
+        raise indexer.IndexCompatibilityError("The local embedder changed models during the call; try again.")
+    return vectors

package/model_defaults.py

@@ -1,70 +1,70 @@
-"""Preenche modelos recomendados somente após consultar o catálogo do gateway configurado."""
-
-import re
-
-import config
-import model_catalog
-
-
-# Matched as the last path/dot segment of the catalog id, so "gpt-4o-mini" also finds "openai/gpt-4o-mini" (OpenRouter)
-# and "openai.gpt-4o-mini" (LiteLLM aliases). Router: small, no reasoning (it runs before tool calls).
-RECOMMENDED_MODELS = {
-    "router_model": ("chat", "gpt-4o-mini"),
-    "scope_model": ("chat", "gpt-5-mini"),
-    "research_model": ("chat", "gpt-oss-20b"),
-    "embedding_model": ("embedding", "text-embedding-3-small"),
-    "rerank_model": ("rerank", "rerank-3-5"),
-}
-
-
-def _matching(catalog, name):
-    return next((model_id for model_id in sorted(catalog) if re.split(r"[/.:]", model_id)[-1] == name
-                 or model_id.endswith(("/" + name, "." + name)) or model_id == name), None)
-
-
-def ensure_recommended_models(key_ready):
-    """Preenche só campos vazios e só com IDs presentes no catálogo permitido.
-
-    Retorna os campos ainda vazios e uma explicação curta para a tela de setup/tray.
-    Um arquivo corrompido ou uma seleção manual nunca é substituído.
-    """
-    corrupted = config.corrupted_reason()
-    if corrupted:
-        return {"status": "config_corrupt", "missing": list(RECOMMENDED_MODELS),
-                "message": corrupted}
-
-    cfg = config.load_config()
-    missing = [field for field in RECOMMENDED_MODELS if not cfg.get(field)]
-    if not key_ready:
-        return {"status": "needs_key", "missing": missing,
-                "message": "Model gateway unavailable; check the base URL and the API key."}
-    if not missing:
-        return {"status": "ready", "missing": [], "message": "Models configured."}
-
-    try:
-        available = {mode: set(model_catalog.list_models(mode)) for mode in
-                     {RECOMMENDED_MODELS[field][0] for field in missing}}
-    except Exception:
-        return {"status": "catalog_unavailable", "missing": missing,
-                "message": "Catalog unavailable. Check the base URL, the API key and the connection to the gateway."}
-
-    choices = {field: found for field in missing
-               for mode, name in [RECOMMENDED_MODELS[field]]
-               for found in [_matching(available[mode], name)] if found}
-    if choices:
-        def fill_empty(current):
-            for field, model_id in choices.items():
-                if not current.get(field):
-                    current[field] = model_id
-
-        try:
-            cfg = config.update_config(fill_empty)
-        except (config.ConfigCorruptedError, OSError):
-            return {"status": "config_corrupt", "missing": missing,
-                    "message": "Could not save the configuration. Open Smart Tool to check the file."}
-
-    missing = [field for field in RECOMMENDED_MODELS if not cfg.get(field)]
-    if missing:
-        return {"status": "needs_models", "missing": missing,
-                "message": "Some recommended models are not in this gateway's catalog. Choose them in the settings."}
-    return {"status": "ready", "missing": [], "message": "Recommended models configured."}
+"""Preenche modelos recomendados somente após consultar o catálogo do gateway configurado."""
+
+import re
+
+import config
+import model_catalog
+
+
+# Matched as the last path/dot segment of the catalog id, so "gpt-4o-mini" also finds "openai/gpt-4o-mini" (OpenRouter)
+# and "openai.gpt-4o-mini" (LiteLLM aliases). Router: small, no reasoning (it runs before tool calls).
+RECOMMENDED_MODELS = {
+    "router_model": ("chat", "gpt-4o-mini"),
+    "scope_model": ("chat", "gpt-5-mini"),
+    "research_model": ("chat", "gpt-oss-20b"),
+    "embedding_model": ("embedding", "text-embedding-3-small"),
+    "rerank_model": ("rerank", "rerank-3-5"),
+}
+
+
+def _matching(catalog, name):
+    return next((model_id for model_id in sorted(catalog) if re.split(r"[/.:]", model_id)[-1] == name
+                 or model_id.endswith(("/" + name, "." + name)) or model_id == name), None)
+
+
+def ensure_recommended_models(key_ready):
+    """Preenche só campos vazios e só com IDs presentes no catálogo permitido.
+
+    Retorna os campos ainda vazios e uma explicação curta para a tela de setup/tray.
+    Um arquivo corrompido ou uma seleção manual nunca é substituído.
+    """
+    corrupted = config.corrupted_reason()
+    if corrupted:
+        return {"status": "config_corrupt", "missing": list(RECOMMENDED_MODELS),
+                "message": corrupted}
+
+    cfg = config.load_config()
+    missing = [field for field in RECOMMENDED_MODELS if not cfg.get(field)]
+    if not key_ready:
+        return {"status": "needs_key", "missing": missing,
+                "message": "Model gateway unavailable; check the base URL and the API key."}
+    if not missing:
+        return {"status": "ready", "missing": [], "message": "Models configured."}
+
+    try:
+        available = {mode: set(model_catalog.list_models(mode)) for mode in
+                     {RECOMMENDED_MODELS[field][0] for field in missing}}
+    except Exception:
+        return {"status": "catalog_unavailable", "missing": missing,
+                "message": "Catalog unavailable. Check the base URL, the API key and the connection to the gateway."}
+
+    choices = {field: found for field in missing
+               for mode, name in [RECOMMENDED_MODELS[field]]
+               for found in [_matching(available[mode], name)] if found}
+    if choices:
+        def fill_empty(current):
+            for field, model_id in choices.items():
+                if not current.get(field):
+                    current[field] = model_id
+
+        try:
+            cfg = config.update_config(fill_empty)
+        except (config.ConfigCorruptedError, OSError):
+            return {"status": "config_corrupt", "missing": missing,
+                    "message": "Could not save the configuration. Open Smart Tool to check the file."}
+
+    missing = [field for field in RECOMMENDED_MODELS if not cfg.get(field)]
+    if missing:
+        return {"status": "needs_models", "missing": missing,
+                "message": "Some recommended models are not in this gateway's catalog. Choose them in the settings."}
+    return {"status": "ready", "missing": [], "message": "Recommended models configured."}

package/package.json

@@ -1,35 +1,35 @@
-{
-  "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.0",
-  "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",
-  "homepage": "https://allansantos-dv.github.io/smart-tool/",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/AllanSantos-DV/smart-tool-dist.git"
-  },
-  "keywords": [
-    "mcp",
-    "claude-code",
-    "codex",
-    "semantic-search",
-    "web-search",
-    "coding-agent"
-  ],
-  "bin": {
-    "smart-tool": "bin/smart-tool.mjs"
-  },
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@allansantos-dev/smart-tool",
+  "version": "0.9.2",
+  "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",
+  "homepage": "https://allansantos-dv.github.io/smart-tool/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AllanSantos-DV/smart-tool-dist.git"
+  },
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "codex",
+    "semantic-search",
+    "web-search",
+    "coding-agent"
+  ],
+  "bin": {
+    "smart-tool": "bin/smart-tool.mjs"
+  },
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}