local-codebase-indexer 0.2.0__py3-none-any.whl

local_codebase_indexer/dataflow.py

@@ -0,0 +1,250 @@
+"""Data access queries: who reads / writes / executes a table or stored procedure, and what a procedure touches.
+
+Direct accesses come from the ``data_access`` table. Indirect ones follow SQL objects: if procedure P writes
+table T, then everything that executes P (C# code or other procedures) is an indirect writer of T, found up to
+``MAX_DEPTH`` hops. Accesses with ``uncertain`` confidence (dynamic SQL) are never mixed into the confirmed lists;
+they are reported as ``possible``. Call chains between C# methods are not followed here, use ``relations``.
+"""
+
+from __future__ import annotations
+
+import re
+import sqlite3
+from collections import deque
+
+MAX_DEPTH = 4
+LIST_CAP = 200
+SQL_OBJECT_KINDS = ("table", "procedure", "view", "function")
+_CONF = {"confirmed": 0, "probable": 1, "uncertain": 2}
+
+WRITE_WORDS = {
+    "write", "writes", "written", "writing", "update", "updates", "modify", "modifies", "modifying", "insert",
+    "inserts", "delete", "deletes", "change", "changes", "save", "saves", "persist", "persists", "populate",
+    "populates", "寫入", "寫", "更新", "修改", "新增", "刪除", "異動", "變更", "儲存",
+    "写入", "写", "删除", "变更", "储存",
+}
+READ_WORDS = {
+    "read", "reads", "select", "selects", "query", "queries", "fetch", "fetches", "load", "loads", "retrieve",
+    "retrieves", "讀取", "讀", "查詢", "取得", "撈", "读取", "读", "查询", "取得",
+}
+TOUCH_WORDS = {
+    "touch", "touches", "access", "accesses", "reference", "references", "use", "uses", "used", "using",
+    "depend", "depends", "involving", "存取", "使用", "用到", "相關", "涉及", "相关",
+}
+CALL_WORDS = {
+    "call", "calls", "called", "execute", "executes", "executed", "invoke", "invokes", "invoked", "exec", "run",
+    "runs", "呼叫", "執行", "被誰", "誰用", "调用", "执行", "被谁",
+}
+
+
+def object_key(name: str) -> str:
+    """Lower-case last segment of a possibly schema / database qualified, bracketed name."""
+    parts = [p.strip("[]\"` ") for p in name.strip().split(".")]
+    return (parts[-1] if parts else "").lower()
+
+
+def detect_intents(query: str) -> set[str]:
+    words = set(re.findall(r"[A-Za-z]+", query.lower()))
+    out = set()
+    for intent, vocab in (("write", WRITE_WORDS), ("read", READ_WORDS), ("touch", TOUCH_WORDS), ("call", CALL_WORDS)):
+        if words & vocab or any((not v.isascii()) and v in query for v in vocab):
+            out.add(intent)
+    return out
+
+
+def known_object_keys(conn: sqlite3.Connection) -> set[str]:
+    keys = {r[0] for r in conn.execute("SELECT DISTINCT target_key FROM data_access WHERE target_key != '?'")}
+    keys |= {r[0].lower() for r in conn.execute(
+        f"SELECT symbol_name FROM symbols WHERE symbol_type IN ({','.join('?' * len(SQL_OBJECT_KINDS))})",
+        SQL_OBJECT_KINDS)}
+    return keys
+
+
+class _Lookup:
+    def __init__(self, conn: sqlite3.Connection):
+        self.conn = conn
+        self._sym: dict[str, sqlite3.Row | None] = {}
+
+    def symbol(self, sid: str | None):
+        if not sid:
+            return None
+        if sid not in self._sym:
+            self._sym[sid] = self.conn.execute(
+                "SELECT id, symbol_name, symbol_type, qualified_name, file_path, start_line FROM symbols WHERE id=?",
+                (sid,)).fetchone()
+        return self._sym[sid]
+
+    def entry(self, row: sqlite3.Row, depth: int = 0, chain: list[str] | None = None) -> dict:
+        s = self.symbol(row["source_id"])
+        return {
+            "source": (s["qualified_name"] or s["symbol_name"]) if s else row["file_path"],
+            "source_type": s["symbol_type"] if s else "file",
+            "source_id": row["source_id"],
+            "file_path": row["file_path"],
+            "line": row["line"],
+            "target": row["target_name"],
+            "op": row["op"],
+            "access": row["access"],
+            "via": row["via"],
+            "confidence": row["confidence"],
+            "evidence": row["evidence"],
+            "detail": row["detail"],
+            "depth": depth,
+            "via_chain": chain or [],
+        }
+
+
+def _sort(entries: list[dict]) -> list[dict]:
+    return sorted(entries, key=lambda e: (e["depth"], _CONF[e["confidence"]], e["file_path"], e["line"]))
+
+
+def _definitions(conn: sqlite3.Connection, key: str) -> list[dict]:
+    return [
+        {"file_path": r["file_path"], "line": r["start_line"], "type": r["symbol_type"],
+         "qualified_name": r["qualified_name"], "id": r["id"]}
+        for r in conn.execute(
+            f"SELECT id, file_path, start_line, symbol_type, qualified_name FROM symbols "
+            f"WHERE lower(symbol_name)=? AND symbol_type IN ({','.join('?' * len(SQL_OBJECT_KINDS))}) "
+            f"ORDER BY file_path, start_line", (key, *SQL_OBJECT_KINDS))
+    ]
+
+
+def _expand_indirect(conn: sqlite3.Connection, lk: _Lookup, direct: list[dict], max_depth: int) -> list[dict]:
+    """Accessors of the SQL objects that themselves access the target (procedures executing procedures, views
+    read by code, ...). Each result keeps the effective access of the direct entry it descends from."""
+    out: list[dict] = []
+    seen = {(e["source_id"], e["line"]) for e in direct}
+    queue = deque()
+    for e in direct:
+        if e["source_type"] in ("procedure", "view", "function"):
+            queue.append((e, e["via_chain"] + [lk.symbol(e["source_id"])["symbol_name"]]))
+    while queue:
+        entry, chain = queue.popleft()
+        if len(chain) > max_depth:
+            continue
+        key = chain[-1].lower()
+        for r in conn.execute(
+            "SELECT * FROM data_access WHERE target_key=? AND access IN ('exec','read') AND confidence != 'uncertain'",
+            (key,),
+        ):
+            sig = (r["source_id"], r["line"])
+            if sig in seen:
+                continue
+            seen.add(sig)
+            e = lk.entry(r, depth=len(chain), chain=list(chain))
+            e["access"], e["op"] = entry["access"], entry["op"]  # effective access on the original target
+            out.append(e)
+            if e["source_type"] in ("procedure", "view", "function"):
+                queue.append((e, chain + [lk.symbol(e["source_id"])["symbol_name"]]))
+    return out
+
+
+def _touches(conn: sqlite3.Connection, lk: _Lookup, definitions: list[dict], max_depth: int) -> dict:
+    """What a procedure / view / function reads, writes and executes, following nested procedure calls."""
+    reads, writes, execs, dynamic = [], [], [], []
+    seen_obj = set()
+    queue = deque((d["id"], [], 0) for d in definitions)
+    while queue:
+        sid, chain, depth = queue.popleft()
+        if sid in seen_obj:
+            continue
+        seen_obj.add(sid)
+        for r in conn.execute("SELECT * FROM data_access WHERE source_id=? ORDER BY line", (sid,)):
+            e = lk.entry(r, depth=depth, chain=chain)
+            if r["op"] == "dynamic" or r["confidence"] == "uncertain":
+                dynamic.append(e)
+            elif r["access"] == "write":
+                writes.append(e)
+            elif r["access"] == "read":
+                reads.append(e)
+            elif r["access"] == "exec":
+                execs.append(e)
+                if depth < max_depth:
+                    for d in _definitions(conn, r["target_key"]):
+                        if d["type"] in ("procedure", "function", "view"):
+                            queue.append((d["id"], chain + [r["target_name"]], depth + 1))
+    return {"reads": _sort(reads)[:LIST_CAP], "writes": _sort(writes)[:LIST_CAP],
+            "executes": _sort(execs)[:LIST_CAP], "dynamic_sql": _sort(dynamic)[:LIST_CAP]}
+
+
+def data_access(conn: sqlite3.Connection, object_name: str, max_depth: int = MAX_DEPTH) -> dict:
+    key = object_key(object_name)
+    lk = _Lookup(conn)
+    defs = _definitions(conn, key)
+    rows = conn.execute("SELECT * FROM data_access WHERE target_key=? ORDER BY file_path, line", (key,)).fetchall()
+    if not defs and not rows:
+        like = [r[0] for r in conn.execute(
+            "SELECT DISTINCT target_name FROM data_access WHERE target_key LIKE ? AND target_key != '?' LIMIT 10",
+            (f"%{key}%",))]
+        like += [r[0] for r in conn.execute(
+            f"SELECT DISTINCT symbol_name FROM symbols WHERE symbol_type IN ({','.join('?' * len(SQL_OBJECT_KINDS))}) "
+            f"AND lower(symbol_name) LIKE ? LIMIT 10", (*SQL_OBJECT_KINDS, f"%{key}%"))]
+        return {"object": object_name, "key": key, "found": False, "suggestions": sorted(set(like))[:10]}
+
+    if defs:
+        kind = defs[0]["type"]
+    else:
+        kinds = [r["target_kind"] for r in rows]
+        kind = max(set(kinds), key=kinds.count) if kinds else "unknown"
+
+    direct = [lk.entry(r) for r in rows]
+    confirmed = [e for e in direct if e["confidence"] != "uncertain"]
+    possible = [e for e in direct if e["confidence"] == "uncertain"]
+    indirect = _expand_indirect(conn, lk, [e for e in confirmed if e["access"] in ("write", "read", "exec")], max_depth)
+
+    def pick(access: str) -> list[dict]:
+        return _sort([e for e in confirmed + indirect if e["access"] == access])
+
+    result = {
+        "object": object_name, "key": key, "found": True, "kind": kind, "definitions": defs,
+        "readers": pick("read")[:LIST_CAP],
+        "writers": pick("write")[:LIST_CAP],
+        "executed_by": pick("exec")[:LIST_CAP],
+        "mapped_by": _sort([e for e in confirmed if e["access"] == "map"]),
+        "possible": _sort(possible)[:LIST_CAP],
+        "notes": [],
+    }
+    if kind in ("procedure", "function", "view") and defs:
+        result["touches"] = _touches(conn, lk, [d for d in defs if d["type"] == kind], max_depth)
+    # dynamic SQL elsewhere whose text names this object
+    word = re.compile(rf"(?<![\w$]){re.escape(key)}(?![\w$])", re.I)
+    for r in conn.execute("SELECT * FROM data_access WHERE target_key='?' AND op='dynamic'"):
+        if word.search(r["evidence"] or ""):
+            result["possible"].append(lk.entry(r))
+    result["notes"].append(
+        "Static analysis: dynamic SQL is listed under 'possible' and cannot be resolved. C# call chains are not "
+        "followed; use the relations tool for who calls a C# method.")
+    return result
+
+
+def accessors_for_search(conn: sqlite3.Connection, key: str, intents: set[str]) -> list[dict]:
+    """Ordered accessors of ``key`` that match the intents of a natural language query (empty when the intent
+    does not apply to the object)."""
+    res = data_access(conn, key, max_depth=2)
+    if not res["found"]:
+        return []
+    kind = res["kind"]
+    picked: list[dict] = []
+    if kind in ("procedure", "function"):
+        if intents & {"call", "touch"}:
+            picked = res["executed_by"]
+    else:
+        want = set()
+        if "write" in intents:
+            want.add("write")
+        if "read" in intents:
+            want.add("read")
+        if "touch" in intents or "call" in intents:
+            want |= {"read", "write"}
+        for e in res["writers"] + res["readers"]:
+            if e["access"] in want:
+                picked.append(e)
+        if "touch" in intents or "call" in intents:
+            picked += res["mapped_by"]
+    seen, out = set(), []
+    for e in _sort(picked):
+        sig = (e["source_id"], e["file_path"], e["line"])
+        if sig not in seen:
+            seen.add(sig)
+            out.append(e)
+    return out

local_codebase_indexer/db.py

@@ -0,0 +1,194 @@
+"""SQLite storage layer: schema from index.md section 2 plus a few helper tables."""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+
+INDEX_DIR_NAME = ".ai_context"
+DB_NAME = "indexer.db"
+
+SCHEMA = """
+-- 1. File metadata cache
+CREATE TABLE IF NOT EXISTS files (
+    file_path TEXT PRIMARY KEY,
+    last_modified INTEGER NOT NULL,
+    md5_hash TEXT NOT NULL,
+    language TEXT NOT NULL
+);
+
+-- 2. Syntactic symbol table (AST extraction)
+CREATE TABLE IF NOT EXISTS symbols (
+    id TEXT PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    symbol_name TEXT NOT NULL,
+    symbol_type TEXT NOT NULL,
+    parent_id TEXT,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    signature TEXT,
+    qualified_name TEXT,
+    type_name TEXT,
+    min_args INTEGER,
+    max_args INTEGER,
+    FOREIGN KEY(file_path) REFERENCES files(file_path)
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(symbol_name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+
+-- 3. Dependency topology (file level)
+CREATE TABLE IF NOT EXISTS dependencies (
+    source_path TEXT NOT NULL,
+    target_path TEXT NOT NULL,
+    dependency_type TEXT NOT NULL,
+    PRIMARY KEY (source_path, target_path, dependency_type)
+);
+CREATE INDEX IF NOT EXISTS idx_dep_target ON dependencies(target_path);
+
+-- Raw, unresolved references captured from the AST (import / base / ident).
+-- Dependencies and symbol relations are resolved from this table.
+CREATE TABLE IF NOT EXISTS raw_refs (
+    file_path TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    line INTEGER NOT NULL,
+    owner TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (file_path, kind, name, owner)
+);
+CREATE INDEX IF NOT EXISTS idx_refs_name ON raw_refs(kind, name);
+
+-- 5. Chunk metadata mapping
+CREATE TABLE IF NOT EXISTS chunk_metadata (
+    rowid INTEGER PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    raw_text TEXT NOT NULL,
+    symbol_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_chunk_file ON chunk_metadata(file_path);
+
+-- 4. Vector storage. index.md names this vss_chunks (sqlite-vss); this
+-- implementation stores float32 BLOBs and does cosine search with numpy so no
+-- native SQLite extension is required.
+CREATE TABLE IF NOT EXISTS vss_chunks (
+    rowid INTEGER PRIMARY KEY,
+    chunk_embedding BLOB NOT NULL
+);
+
+-- Keyword layer (FTS5) over chunk text; rowid == chunk_metadata.rowid
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(search_text, tokenize='unicode61');
+
+CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+-- Data access: which table / procedure a SQL object or C# method reads, writes, executes or maps.
+-- target_key is the lower-case last name segment; "?" marks dynamic SQL whose target is unknown.
+CREATE TABLE IF NOT EXISTS data_access (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path TEXT NOT NULL,
+    source_id TEXT,
+    line INTEGER NOT NULL,
+    target_key TEXT NOT NULL,
+    target_name TEXT NOT NULL,
+    qualifier TEXT NOT NULL DEFAULT '',
+    target_kind TEXT NOT NULL,
+    access TEXT NOT NULL,
+    op TEXT NOT NULL,
+    via TEXT NOT NULL,
+    confidence TEXT NOT NULL,
+    evidence TEXT NOT NULL DEFAULT '',
+    detail TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_da_target ON data_access(target_key);
+CREATE INDEX IF NOT EXISTS idx_da_file ON data_access(file_path);
+CREATE INDEX IF NOT EXISTS idx_da_source ON data_access(source_id);
+
+-- C# call sites as seen in the syntax tree, and the resolved symbol-level call graph derived from them.
+CREATE TABLE IF NOT EXISTS call_sites (
+    file_path TEXT NOT NULL,
+    caller_id TEXT,
+    line INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    argc INTEGER NOT NULL,
+    recv_kind TEXT NOT NULL,
+    recv_name TEXT NOT NULL DEFAULT '',
+    recv_type TEXT NOT NULL DEFAULT '',
+    recv_expr TEXT NOT NULL DEFAULT '',
+    is_ctor INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_cs_file ON call_sites(file_path);
+CREATE TABLE IF NOT EXISTS calls (
+    caller_id TEXT NOT NULL,
+    callee_id TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    line INTEGER NOT NULL,
+    confidence TEXT NOT NULL,
+    reason TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_calls_callee ON calls(callee_id);
+CREATE INDEX IF NOT EXISTS idx_calls_caller ON calls(caller_id);
+
+-- Files that could not be indexed on the last attempt. They are retried on every update.
+CREATE TABLE IF NOT EXISTS index_failures (
+    file_path TEXT PRIMARY KEY,
+    error TEXT NOT NULL,
+    failed_at INTEGER NOT NULL
+);
+"""
+
+# Bump when the stored data layout or parsing output changes; a mismatch triggers a full rebuild.
+INDEX_VERSION = "4"
+
+
+def index_dir(root: str) -> str:
+    return os.path.join(root, INDEX_DIR_NAME)
+
+
+def default_db_path(root: str) -> str:
+    return os.path.join(index_dir(root), DB_NAME)
+
+
+def connect(db_path: str) -> sqlite3.Connection:
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+    # keep the index out of version control
+    gi = os.path.join(os.path.dirname(db_path), ".gitignore")
+    if not os.path.exists(gi):
+        with open(gi, "w", encoding="utf-8") as f:
+            f.write("*\n")
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    conn.executescript(SCHEMA)
+    _migrate(conn)
+    return conn
+
+
+def _migrate(conn: sqlite3.Connection) -> None:
+    """Add columns that older index files lack (the index version check then rebuilds their content)."""
+    have = {r[1] for r in conn.execute("PRAGMA table_info(symbols)")}
+    for col, decl in (("type_name", "TEXT"), ("min_args", "INTEGER"), ("max_args", "INTEGER")):
+        if col not in have:
+            conn.execute(f"ALTER TABLE symbols ADD COLUMN {col} {decl}")
+
+
+def get_meta(conn: sqlite3.Connection, key: str) -> str | None:
+    row = conn.execute("SELECT value FROM meta WHERE key=?", (key,)).fetchone()
+    return row["value"] if row else None
+
+
+def set_meta(conn: sqlite3.Connection, key: str, value: str) -> None:
+    conn.execute(
+        "INSERT INTO meta(key, value) VALUES(?, ?) "
+        "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+        (key, value),
+    )
+
+
+def clear_all(conn: sqlite3.Connection) -> None:
+    for t in ("files", "symbols", "dependencies", "raw_refs", "chunk_metadata", "vss_chunks", "chunks_fts",
+              "index_failures", "data_access", "call_sites", "calls"):
+        conn.execute(f"DELETE FROM {t}")

local_codebase_indexer/embedder.py

@@ -0,0 +1,137 @@
+"""Semantic layer: local embedding backends (384 dimensions, no cloud calls).
+
+Two backends:
+
+* ``HashingEmbedder`` (default): dependency-light signed feature hashing over
+  identifier sub-words, whole identifiers, bigrams and CJK character bigrams.
+  It is a lexical-semantic approximation, deterministic and fast, but it does
+  not understand synonyms.
+* ``OnnxEmbedder``: real transformer embeddings (all-MiniLM-L6-v2 or
+  bge-small-en-v1.5 exported to ONNX). Enabled by setting ``INDEXER_ONNX_MODEL``
+  to a directory containing ``model.onnx`` and ``tokenizer.json``.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import zlib
+from typing import Sequence
+
+import numpy as np
+
+DIM = 384
+
+_WORD_RE = re.compile(r"[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+|[一-鿿]+")
+_IDENT_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_STOP = {
+    "the", "a", "an", "of", "to", "in", "is", "for", "and", "or", "if", "else", "return",
+    "var", "new", "this", "public", "private", "protected", "static", "void", "int", "string",
+    "bool", "true", "false", "null", "self", "def", "class", "import", "from", "using", "get", "set",
+}
+
+
+def split_identifier(token: str) -> list[str]:
+    return [p.lower() for p in _WORD_RE.findall(token.replace("_", " "))]
+
+
+def tokenize(text: str) -> list[str]:
+    """Words for lexical features: whole identifiers plus their camelCase/snake_case parts."""
+    out: list[str] = []
+    for ident in _IDENT_RE.findall(text):
+        parts = split_identifier(ident)
+        if len(parts) > 1:
+            out.append(ident.lower())
+        out.extend(parts)
+    for run in re.findall(r"[一-鿿]+", text):
+        out.extend(run[i:i + 2] for i in range(max(1, len(run) - 1)))
+    return out
+
+
+class HashingEmbedder:
+    name = "hashing-384-v1"
+    dim = DIM
+
+    def _vec(self, text: str) -> np.ndarray:
+        v = np.zeros(DIM, dtype=np.float32)
+        toks = [t for t in tokenize(text) if t not in _STOP and len(t) > 1]
+        if not toks:
+            return v
+        counts: dict[str, int] = {}
+        for t in toks:
+            counts[t] = counts.get(t, 0) + 1
+        for i in range(len(toks) - 1):
+            bg = toks[i] + " " + toks[i + 1]
+            counts[bg] = counts.get(bg, 0) + 1
+        for feat, c in counts.items():
+            h = zlib.crc32(feat.encode("utf-8"))
+            idx = h % DIM
+            sign = 1.0 if (h >> 16) & 1 else -1.0
+            v[idx] += sign * (1.0 + math.log(c))
+        n = float(np.linalg.norm(v))
+        return v / n if n else v
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        return np.stack([self._vec(t) for t in texts]) if texts else np.zeros((0, DIM), np.float32)
+
+
+class OnnxEmbedder:
+    dim = DIM
+
+    def __init__(self, model_dir: str):
+        import onnxruntime as ort
+        from tokenizers import Tokenizer
+
+        self.name = "onnx:" + os.path.basename(os.path.abspath(model_dir))
+        self.tok = Tokenizer.from_file(os.path.join(model_dir, "tokenizer.json"))
+        self.tok.enable_truncation(max_length=256)
+        self.tok.enable_padding()
+        self.session = ort.InferenceSession(
+            os.path.join(model_dir, "model.onnx"), providers=["CPUExecutionProvider"]
+        )
+        self.input_names = {i.name for i in self.session.get_inputs()}
+        # bge models pool the [CLS] token and expect an instruction prefix on queries; MiniLM-style models mean-pool
+        self.pooling = os.environ.get("INDEXER_ONNX_POOLING", "mean").lower()
+        if self.pooling not in ("mean", "cls"):
+            raise ValueError("INDEXER_ONNX_POOLING must be 'mean' or 'cls'")
+        self.query_prefix = os.environ.get("INDEXER_ONNX_QUERY_PREFIX", "")
+        self.name += f":{self.pooling}"
+        out_dim = self.session.get_outputs()[0].shape[-1]
+        if isinstance(out_dim, int):
+            self.dim = out_dim
+
+    def embed_query(self, text: str) -> np.ndarray:
+        return self.embed([self.query_prefix + text])[0]
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        if not texts:
+            return np.zeros((0, self.dim), np.float32)
+        out = []
+        for i in range(0, len(texts), 16):
+            enc = self.tok.encode_batch(list(texts[i:i + 16]))
+            ids = np.array([e.ids for e in enc], dtype=np.int64)
+            mask = np.array([e.attention_mask for e in enc], dtype=np.int64)
+            feeds = {"input_ids": ids, "attention_mask": mask}
+            if "token_type_ids" in self.input_names:
+                feeds["token_type_ids"] = np.zeros_like(ids)
+            hidden = self.session.run(None, {k: v for k, v in feeds.items() if k in self.input_names})[0]
+            if self.pooling == "cls":
+                pooled = hidden[:, 0, :]
+            else:
+                m = mask[..., None].astype(np.float32)
+                pooled = (hidden * m).sum(1) / np.clip(m.sum(1), 1e-9, None)
+            pooled /= np.clip(np.linalg.norm(pooled, axis=1, keepdims=True), 1e-9, None)
+            out.append(pooled.astype(np.float32))
+        return np.vstack(out)
+
+
+def get_embedder():
+    model_dir = os.environ.get("INDEXER_ONNX_MODEL")
+    if model_dir:
+        try:
+            return OnnxEmbedder(model_dir)
+        except Exception as exc:  # fall back, but say so
+            import sys
+            print(f"[indexer] ONNX embedder unavailable ({exc}); using hashing embedder", file=sys.stderr)
+    return HashingEmbedder()