@allansantos-dev/smart-tool 0.0.0-stage → 0.9.0

package/local_embedder.py

@@ -0,0 +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

package/model_adapters/openai_compatible.py

@@ -0,0 +1,57 @@
+"""Built-in model adapter for any OpenAI-compatible API: OpenAI, OpenRouter, a LiteLLM proxy, Ollama, vLLM...
+
+The base URL ends where the OpenAI SDK's `base_url` ends (usually `/v1`); the API key, when given, goes as a Bearer
+token. A model adapter is a module with NAME, LABEL, FIELDS, request() and verify(); see gateway.py for the contract.
+"""
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+
+NAME = "openai_compatible"
+LABEL = "OpenAI-compatible"
+FIELDS = (
+    {"name": "base_url", "label": "Base URL", "required": True, "placeholder": "https://api.openai.com/v1",
+     "hint": "Where the API starts, like the OpenAI SDK base_url: https://openrouter.ai/api/v1, "
+             "http://localhost:11434/v1."},
+    {"name": "api_key", "label": "API key", "secret": True,
+     "hint": "Optional (Ollama and local proxies do not need one)."},
+)
+_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
+def _base(options):
+    url = str(options.get("base_url") or "").strip().rstrip("/")
+    parsed = urllib.parse.urlparse(url)
+    if parsed.scheme not in ("http", "https") or not parsed.hostname or parsed.query or parsed.fragment:
+        raise ValueError("Enter the OpenAI-compatible base URL, for example https://api.openai.com/v1.")
+    return url
+
+
+def request(options, route, body=None, timeout=15):
+    """POST when body is given, GET otherwise. Returns (json, response headers); HTTP errors propagate."""
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {"Content-Type": "application/json"} if data is not None else {}
+    if options.get("api_key"):
+        headers["Authorization"] = "Bearer " + options["api_key"]
+    req = urllib.request.Request(f"{_base(options)}/{route}", data=data, headers=headers,
+                                 method="POST" if data is not None else "GET")
+    with _OPENER.open(req, timeout=timeout) as response:
+        return json.load(response), response.headers
+
+
+def verify(options):
+    url = _base(options)
+    try:
+        data, _headers = request(options, "models", timeout=10)
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            raise RuntimeError(f"{url} rejected the API key (HTTP {exc.code}).") from None
+        if exc.code == 404:
+            raise RuntimeError(f"{url}/models does not exist (HTTP 404): the base URL must end where the API "
+                               "starts, usually at /v1.") from None
+        raise RuntimeError(f"{url} answered HTTP {exc.code} on /models.") from None
+    except (OSError, ValueError) as exc:
+        raise RuntimeError(f"{url} did not respond on /models: {getattr(exc, 'reason', exc)}") from None
+    if not isinstance(data, dict) or not isinstance(data.get("data"), list):
+        raise RuntimeError(f"{url}/models did not return the list in OpenAI format ({{\"data\": [...]}}).")

package/model_catalog.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Catálogo de modelos do gateway para `configure.py` e a tela de setup do Smart Tool.
+
+`/v1/model/info` (proxy LiteLLM) traz o `mode` de cada modelo; um gateway OpenAI padrão só tem `/v1/models`, e aí o
+modo sai do nome (embed, rerank; o resto é chat). A lista é sugestão: a tela aceita qualquer id.
+"""
+import re
+import threading
+import urllib.error
+
+import gateway
+import model_client
+
+_LIGHTWEIGHT_KEYWORDS = ("mini", "nano", "flash", "lite", "haiku", "small")
+_LIGHTWEIGHT_RE = re.compile(
+    r"\b(?:" + "|".join(_LIGHTWEIGHT_KEYWORDS) + r")\b"
+)
+
+_cache_lock = threading.Lock()
+_cached_rows = None
+_cached_selection_id = None
+
+
+def is_lightweight(model_id):
+    """Heurística por palavra completa (o catálogo não tem campo de tier) — cobre os provedores sem hardcode.
+    \\b evita falso positivo tipo "gemini" casando a substring "mini"."""
+    model_id = (model_id or "").lower()
+    return bool(_LIGHTWEIGHT_RE.search(model_id))
+
+
+def _fetch_rows():
+    """`/v1/model/info` devolve chat+embedding+rerank misturados no mesmo payload --
+    cacheado pra vida do processo. Lock só em volta do preenchimento: leitura depois de
+    populado é sempre segura, sem necessidade de guarda."""
+    global _cached_rows, _cached_selection_id
+    selected = gateway.fingerprint()
+    if _cached_rows is not None and selected == _cached_selection_id:
+        return _cached_rows
+    with _cache_lock:
+        if _cached_rows is None or selected != _cached_selection_id:
+            token = model_client.get_token()
+            try:
+                rows = model_client.fetch("/v1/model/info", token).get("data", [])
+            except urllib.error.HTTPError as exc:
+                exc.close()
+                if exc.code not in (400, 404, 405):
+                    raise
+                rows = [{"model_name": row.get("id"), "model_info": {"mode": _mode_from_name(row.get("id") or "")}}
+                        for row in model_client.fetch("/v1/models", token).get("data", [])]
+            _cached_rows = rows
+            _cached_selection_id = selected
+    return _cached_rows
+
+
+def _mode_from_name(model_id):
+    name = model_id.lower()
+    return "rerank" if "rerank" in name else "embedding" if "embed" in name else "chat"
+
+
+def list_models(mode="chat"):
+    """Ids de modelo disponíveis para a key atual num dado `mode`
+    (`chat`, `embedding` ou `rerank`), deduplicados e ordenados por nome."""
+    rows = _fetch_rows()
+
+    names = set()
+    for row in rows:
+        info = row.get("model_info") or {}
+        if info.get("mode") != mode:
+            continue
+        name = row.get("model_name")
+        if name:
+            names.add(name)
+
+    return sorted(names)

package/model_client.py

@@ -0,0 +1,38 @@
+"""Smart Tool model client: talks to the configured model gateway through its adapter."""
+import contextvars
+import time
+import usage_meter
+
+import gateway
+
+OFFLINE = contextvars.ContextVar("model_offline", default=None)
+
+
+def get_token():
+    """Kept for callers that pass a token along: credentials now live in the model adapter. Fails when no adapter."""
+    if OFFLINE.get():
+        raise RuntimeError(OFFLINE.get())
+    if gateway.selected()[0] is None:
+        raise RuntimeError("No model gateway configured: choose an adapter in the setup screen.")
+    return ""
+
+
+def fetch(path, token, method="GET", body=None, timeout=15):
+    if OFFLINE.get():
+        raise RuntimeError(OFFLINE.get())
+    started=time.monotonic();result=None;headers=None;failure=None
+    try:
+        result,headers=_fetch(path,token,method,body,timeout)
+        return result
+    except Exception as exc:
+        failure=exc
+        raise
+    finally:
+        usage_meter.record(path,body,result,headers,failure,time.monotonic()-started)
+
+
+def _fetch(path, _token, method="GET", body=None, timeout=15):
+    # Callers name routes as /v1/...; the adapter knows where its API starts.
+    if not path.startswith("/v1/"):
+        raise ValueError("Only /v1/ routes are accepted by this client.")
+    return gateway.request(path[len("/v1/"):], body=body, timeout=timeout)

package/model_defaults.py

@@ -0,0 +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."}

package/package.json

@@ -1,6 +1,35 @@
-{
-  "name": "@allansantos-dev/smart-tool",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "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"
+  }
+}

package/paths.py

@@ -0,0 +1,6 @@
+"""Where Smart Tool keeps its state: ~/.smart-tool (config.json and model adapters) and ~/.smart-tool/data (indexes,
+daemon registry, caches, metrics). Pure stdlib so the installer can import it too."""
+import os
+
+HOME_DIR = os.path.join(os.path.expanduser("~"), ".smart-tool")
+DATA_DIR = os.path.join(HOME_DIR, "data")

package/project_identity.py

@@ -0,0 +1,42 @@
+"""Identidade única de raízes e contenção de caminhos, inclusive junctions Windows."""
+import hashlib
+import os
+
+
+def display_root(root):
+    if not isinstance(root, (str, os.PathLike)) or not str(root).strip():
+        raise ValueError("Provide the project folder.")
+    return os.path.realpath(os.path.abspath(os.path.expanduser(os.fspath(root))))
+
+
+def canonical_root(root):
+    return os.path.normcase(display_root(root))
+
+
+def project_id(root):
+    return hashlib.sha256(canonical_root(root).encode("utf-8")).hexdigest()[:16]
+
+
+def legacy_ids(root):
+    """Chaves antigas conhecidas; a migração copia os dados e preserva a origem."""
+    variants = [os.path.abspath(os.fspath(root)), display_root(root),
+                os.path.normcase(os.path.abspath(os.fspath(root)))]
+    return list(dict.fromkeys(hashlib.sha256(path.encode("utf-8")).hexdigest()[:16]
+                              for path in variants))
+
+
+def within_root(root, candidate):
+    try:
+        base = canonical_root(root)
+        resolved = canonical_root(candidate)
+        return os.path.commonpath([base, resolved]) == base
+    except (OSError, ValueError, TypeError):
+        return False
+
+
+def state_path(path, state_dir):
+    """Valida o alvo antes de remover/substituir arquivos de estado."""
+    absolute = os.path.abspath(path)
+    if not within_root(state_dir, absolute) or canonical_root(absolute) == canonical_root(state_dir):
+        raise ValueError("Operation refused: path is outside the state directory.")
+    return absolute

package/project_insights_ui.py

@@ -0,0 +1,38 @@
+"""Painéis por projeto: consumo, armazenamento seletivo e comparação de visões."""
+STYLE=r'''
+.insights-controls{display:flex;gap:10px;align-items:end;flex-wrap:wrap;margin:16px 0}.insights-controls label{font-size:12px;margin:0 0 4px}.insights-controls select{max-width:100%;min-height:40px}.insights-table-wrap{max-height:340px;overflow:auto;margin:16px 0}.insights-table{width:100%;border-collapse:collapse;font-size:13px}.insights-table th,.insights-table td{text-align:left;vertical-align:top;padding:10px 9px;border-bottom:1px solid var(--border);overflow-wrap:anywhere}.insights-table th{color:var(--muted);font-weight:600}.insights-table td:first-child,.insights-table th:first-child{padding-left:0}.insights-table td button{font-size:12px;min-height:30px;padding:4px 8px}.insights-note{color:var(--muted);font-size:13px;overflow-wrap:anywhere}.insights-summary{display:grid;grid-template-columns:1fr 1fr;gap:0 20px;margin:14px 0}.insights-summary div{padding:10px 0;border-top:1px solid var(--border)}.insights-summary small{display:block}.insights-summary strong{font-size:15px}.cleanup-preview{border:1px solid var(--border);border-radius:8px;padding:16px;margin:16px 0}.comparison-diff{white-space:pre-wrap;overflow-wrap:anywhere;font:12px/1.65 Consolas,monospace;max-height:430px;overflow:auto}.comparison-diff .added{color:var(--good)}.comparison-diff .removed{color:var(--bad)}.comparison-item{width:100%;text-align:left;margin:4px 0}.insights-note:empty{display:none}.insights-panel select{min-width:0}.insights-views{display:grid;grid-template-columns:1fr 1fr;gap:16px}.insights-views select{width:100%}
+@media(max-width:700px){.insights-summary,.insights-views{grid-template-columns:1fr}.insights-table{min-width:490px}.insights-controls>div{max-width:100%}}
+'''
+HTML=r'''
+<details class="insights-panel" id="usage-panel"><summary>Usage and reuse by project and view</summary>
+<div class="insights-controls"><div><label for="usage-days">Period</label><select id="usage-days"><option value="7">7 days</option><option value="30" selected>30 days</option><option value="90">90 days</option><option value="366">1 year</option></select></div><div><label for="usage-view">View</label><select id="usage-view"><option value="">All</option></select></div><button id="usage-load">Refresh usage</button></div><p id="usage-message" class="insights-note">Local counts and usage reported by the gateway. No query text is saved in this telemetry.</p><div id="usage-summary" class="insights-summary"></div><div id="usage-table" class="insights-table-wrap"></div><div id="usage-indexing" class="insights-table-wrap"></div></details>
+<details class="insights-panel" id="storage-panel"><summary>Disk space and view cleanup</summary><div class="insights-controls"><button id="storage-load">Refresh inventory</button></div><p class="insights-note">The active view and pinned views are protected. Cleanup is manual and removes only Smart Tool indexes and cache.</p><div id="storage-summary" class="insights-summary"></div><div id="storage-table" class="insights-table-wrap"></div><label class="check-label"><input id="cleanup-cache" type="checkbox" checked>Also clear vectors no longer used by the stored generations</label><div class="actions"><button id="cleanup-preview" disabled>Preview selected cleanup</button></div><div id="cleanup-plan" class="cleanup-preview" hidden></div><button id="cleanup-apply" class="danger" hidden>Confirm removal of this preview</button><p id="storage-message" class="insights-note"></p></details>
+<details class="insights-panel" id="compare-panel"><summary>Compare two stored views</summary><p class="insights-note">The comparison uses the index content, with no checkout and no new embeddings. Scope differences can also show up as added or removed files.</p><button id="compare-load-views">Load views</button><div class="insights-views"><div><label for="compare-left">View A · base</label><select id="compare-left"></select></div><div><label for="compare-right">View B · compare with A</label><select id="compare-right"></select></div></div><label class="check-label"><input id="compare-relations" type="checkbox" checked>Also compare resolved references and static calls</label><div class="actions"><button id="compare-run" disabled>Compare A → B</button></div><p id="compare-message" class="insights-note"></p><div id="compare-summary" class="insights-summary"></div><div id="compare-files" class="insights-table-wrap"></div><div id="compare-graph"></div><h3 id="compare-file-title"></h3><pre id="compare-diff" class="comparison-diff"></pre></details>
+'''
+SCRIPT=r'''
+window.SmartInsights=(()=>{
+ const $i=id=>document.getElementById(id);let sequence=0,storage=null,plan=null,comparison=null,compareRequest=0,diffRequest=0;
+ const count=n=>Number(n||0).toLocaleString('en-US'),size=n=>n>=1048576?(n/1048576).toLocaleString('en-US',{maximumFractionDigits:2})+' MiB':(n/1024).toLocaleString('en-US',{maximumFractionDigits:1})+' KiB';
+ const phaseNames={index_embedding:'Indexing',query_embedding:'Query',embedding_probe:'Model check',scope:'Scope',rerank:'Rerank',other:'Other step'};
+ function summary(host,rows){host.innerHTML=rows.map(([title,value,note])=>`<div><small>${esc(title)}</small><strong>${esc(value)}</strong>${note?'<small>'+esc(note)+'</small>':''}</div>`).join('')}
+ function table(headers,rows){return '<table class="insights-table"><thead><tr>'+headers.map(x=>'<th>'+esc(x)+'</th>').join('')+'</tr></thead><tbody>'+rows.map(row=>'<tr>'+row.map(value=>'<td>'+value+'</td>').join('')+'</tr>').join('')+'</tbody></table>'}
+ async function run(button,task){const seq=sequence,key=selected;button.disabled=true;try{await task(key,()=>seq===sequence&&key===selected)}catch(e){if(seq===sequence)message(e.message,true)}finally{if(seq===sequence)button.disabled=false}}
+ function clearPlan(){plan=null;$i('cleanup-plan').hidden=true;$i('cleanup-apply').hidden=true;$i('cleanup-preview').disabled=!document.querySelector('#storage-table input[data-storage]:checked')}
+ function reset(){sequence++;storage=null;comparison=null;plan=null;for(const id of ['usage-summary','usage-table','usage-indexing','storage-summary','storage-table','storage-message','compare-summary','compare-files','compare-graph','compare-file-title','compare-diff','compare-message'])$i(id).replaceChildren();$i('usage-view').replaceChildren(new Option('All',''));$i('compare-left').replaceChildren();$i('compare-right').replaceChildren();$i('compare-run').disabled=true;clearPlan();for(const id of ['usage-load','storage-load','compare-load-views'])$i(id).disabled=false;$i('usage-message').textContent='Refresh the usage of this project. The telemetry stores only counts and metadata.'}
+ async function loadUsage(key,valid){const requestedDays=$i('usage-days').value,requestedView=$i('usage-view').value;const data=await api({action:'usage',project_id:key,days:Number($i('usage-days').value),...($i('usage-view').value?{view_id:$i('usage-view').value}:{})});if(!valid()||requestedDays!==$i('usage-days').value||requestedView!==$i('usage-view').value)return;const t=data.totals,old=$i('usage-view').value,views=new Map();for(const row of [...data.daily,...data.indexing])views.set(row.view_id,row.view_label);if(!old)$i('usage-view').replaceChildren(new Option('All',''),...Array.from(views,([id,label])=>new Option(label||id,id)));summary($i('usage-summary'),[['Call attempts',count(t.attempts),count(t.errors)+' with errors'],['Reported tokens',t.token_reports?count((t.prompt_tokens||0)+(t.output_tokens||0)):'Not reported',count(t.token_reports)+' of '+count(t.attempts)+' calls with data'],['Cost reported by the gateway',t.reported_usd==null?'Not reported':new Intl.NumberFormat('en-US',{style:'currency',currency:'USD',maximumFractionDigits:6}).format(t.reported_usd),count(t.price_reports)+' calls with a cost; not the full bill'],['Chunks sent / cache',count(data.indexing.reduce((s,r)=>s+r.embedded_chunks,0))+' / '+count(data.indexing.reduce((s,r)=>s+r.reused_chunks,0)),'Unchanged files are counted separately']]);$i('usage-message').textContent='Loaded period: '+data.days+' days (UTC). '+data.notes.join(' ');$i('usage-table').innerHTML=table(['Date UTC','View / step','Model','Attempts','Reported tokens','Measured characters'],data.daily.slice(0,200).map(r=>[esc(r.day),esc(r.view_label)+'<br>'+esc(phaseNames[r.purpose]||r.purpose),esc(r.model),count(r.attempts),r.token_reports?count(r.prompt_tokens+r.output_tokens):'Not reported',count(r.input_characters)]));$i('usage-indexing').innerHTML=table(['View','Indexing jobs','Chunks sent','Cache reuse','Unchanged files'],data.indexing.map(r=>[esc(r.view_label),count(r.jobs),count(r.embedded_chunks),count(r.reused_chunks),count(r.unchanged_files)]))}
+ function renderStorage(data){storage=data;clearPlan();summary($i('storage-summary'),[['SQLite indexes',size(data.total_bytes)],['Vector cache',size(data.cache_bytes)],['Auxiliary generations',size(data.auxiliary_bytes)],['Stored views',count(data.views.length),'Active and pinned views are protected']]);$i('storage-table').innerHTML=table(['Clear','View','Space','Protection'],data.views.map(v=>[`<input type="checkbox" data-storage="${esc(v.storage_id)}" aria-label="Select ${esc(v.label)} for cleanup" ${v.protected?'disabled':''}>`,esc(v.label)+'<br><small>'+esc(v.commit?.slice(0,10)||'Commit not recorded')+'</small>',size(v.bytes),esc(v.protected_reason||'Can be selected')+`<br><button data-pin="${esc(v.storage_id)}" data-pinned="${v.pinned?'1':'0'}">${v.pinned?'Unpin':'Pin'}</button>`]));$i('storage-message').textContent=data.views.length?'Choose the old views and check the preview before removing.':'No stored views in this project.';clearPlan()}
+ async function loadStorage(key,valid){const data=await api({action:'storage',project_id:key});if(valid())renderStorage(data)}
+ $i('usage-load').onclick=()=>run($i('usage-load'),loadUsage);$i('usage-days').onchange=()=>run($i('usage-load'),loadUsage);$i('usage-view').onchange=()=>run($i('usage-load'),loadUsage);$i('storage-load').onclick=()=>run($i('storage-load'),loadStorage);
+ $i('storage-table').onchange=clearPlan;$i('cleanup-cache').onchange=clearPlan;
+ $i('storage-table').onclick=e=>{const button=e.target.closest('[data-pin]');if(button)run(button,async(key,valid)=>{const data=await api({action:'pin_view',project_id:key,storage_id:button.dataset.pin,pinned:button.dataset.pinned!=='1'});if(valid())renderStorage(data)})};
+ $i('cleanup-preview').onclick=()=>run($i('cleanup-preview'),async(key,valid)=>{const ids=[...document.querySelectorAll('#storage-table input[data-storage]:checked')].map(n=>n.dataset.storage);const data=await api({action:'cleanup_preview',project_id:key,storage_ids:ids,clear_cache:$i('cleanup-cache').checked});if(!valid())return;plan=data;$i('cleanup-plan').hidden=false;$i('cleanup-plan').innerHTML='<h3>Removal preview</h3><ul>'+data.views.map(v=>'<li>'+esc(v.label)+'</li>').join('')+'</ul><p>'+size(data.index_bytes)+' in indexes; '+count(data.unused_vectors)+' unreferenced vectors ('+size(data.vector_bytes)+' of vector content).</p><p class="insights-note">'+esc(data.note||'The final cache size depends on SQLite compaction.')+'</p><p>The project files will be kept.</p>';$i('cleanup-apply').hidden=false});
+ $i('cleanup-apply').onclick=()=>{if(!plan)return;if(!confirm('Remove the views in this preview: '+plan.views.map(v=>v.label).join(', ')+'? The project files will be kept.'))return;run($i('cleanup-apply'),async(key,valid)=>{const data=await api({action:'cleanup_commit',project_id:key,plan_id:plan.plan_id,confirm:true});if(!valid())return;renderStorage(data.storage);$i('storage-message').textContent=data.removed_views+' view(s) removed; '+data.removed_vectors+' vectors removed. '+data.warnings.join(' ');window.SmartMaps?.reset();await refresh()})};
+ async function loadViews(key,valid){compareRequest++;diffRequest++;comparison=null;for(const id of ['compare-summary','compare-files','compare-graph','compare-file-title','compare-diff'])$i(id).replaceChildren();const data=await api({action:'storage',project_id:key});if(!valid())return;const options=data.views.map(v=>[v.storage_id,v.label+(v.current?' (active)':'')]);$i('compare-left').replaceChildren(...options.map(([id,label])=>new Option(label,id)));$i('compare-right').replaceChildren(...options.map(([id,label])=>new Option(label,id)));if(options.length>1)$i('compare-right').selectedIndex=1;$i('compare-run').disabled=options.length<2;$i('compare-message').textContent=options.length<2?'Two indexed views are needed. Run searches on the branches you want to store them.':'Differences will be shown from A to B.'}
+ $i('compare-load-views').onclick=()=>run($i('compare-load-views'),loadViews);
+ for(const id of ['compare-left','compare-right','compare-relations'])$i(id).onchange=()=>{compareRequest++;diffRequest++;comparison=null;for(const host of ['compare-summary','compare-files','compare-graph','compare-file-title','compare-diff'])$i(host).replaceChildren();$i('compare-run').disabled=!$i('compare-left').value||!$i('compare-right').value||$i('compare-left').value===$i('compare-right').value;$i('compare-message').textContent='Selection changed. Run the comparison from A to B.'};
+ function fileButtons(data){const rows=[];for(const kind of ['added','removed','changed'])for(const path of data.files[kind])rows.push([kind==='added'?'Added in B':kind==='removed'?'Missing in B':'Changed',path]);for(const item of data.files.renamed)rows.push(['Rename detected',item.from+' → '+item.to]);return table(['Change','File'],rows.slice(0,1000).map(([kind,path])=>[esc(kind),kind==='Rename detected'?esc(path):`<button data-compare-file="${esc(path)}">${esc(path)}</button>`]))}
+ $i('compare-run').onclick=()=>run($i('compare-run'),async(key,valid)=>{const request=++compareRequest;diffRequest++;const left=$i('compare-left').value,right=$i('compare-right').value;if(!left||!right||left===right)throw Error('Choose two different views.');$i('compare-message').textContent='Comparing the stored snapshots…';const data=await api({action:'compare',project_id:key,left_view:left,right_view:right,relations:$i('compare-relations').checked});if(!valid()||request!==compareRequest)return;comparison={left,right};summary($i('compare-summary'),[['Added in B',count(data.files.added.length)],['Missing in B',count(data.files.removed.length)],['Changed',count(data.files.changed.length)],['Renamed / identical',count(data.files.renamed.length)+' / '+count(data.unchanged)]]);$i('compare-files').innerHTML=fileButtons(data);$i('compare-message').textContent=data.notes.join(' ')+(data.analysis_partial?' Some files/relations could not be analyzed.':'');$i('compare-file-title').textContent='';$i('compare-diff').textContent='';$i('compare-graph').innerHTML=data.relations?Object.entries(data.relations).map(([kind,changes])=>'<details><summary>'+esc(kind==='calls'?'Calls':'References between files')+' · +'+changes.added_count+' / −'+changes.removed_count+'</summary><div class="insights-table-wrap">'+table(['Change','Source → target'],[...changes.added.map(x=>['Added',esc(x[0])+' → '+esc(x[1])]),...changes.removed.map(x=>['Removed',esc(x[0])+' → '+esc(x[1])])])+'</div></details>').join(''):''});
+ $i('compare-files').onclick=e=>{const button=e.target.closest('[data-compare-file]');if(!button||!comparison)return;const chosen={...comparison},request=++diffRequest;run(button,async(key,valid)=>{const data=await api({action:'compare',project_id:key,left_view:chosen.left,right_view:chosen.right,file_path:button.dataset.compareFile,relations:false});if(!valid()||request!==diffRequest||comparison?.left!==chosen.left||comparison?.right!==chosen.right)return;$i('compare-file-title').textContent=button.dataset.compareFile+(button.dataset.compareFile.toLowerCase().endsWith('.docx')?' · extracted text':'');$i('compare-diff').innerHTML=data.diff_error?esc(data.diff_error):(data.diff||'The indexed text is identical; metadata/hashes may have changed.').split('\n').map(line=>'<span class="'+(line.startsWith('+')?'added':line.startsWith('-')?'removed':'')+'">'+esc(line)+'</span>').join('\n');if(data.diff_truncated)$i('compare-message').textContent+=' Diff limited to 1,000 lines / 128,000 characters.'})};
+ return {reset};
+})();
+'''