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

local_codebase_indexer/scanner.py

@@ -0,0 +1,101 @@
+"""Project scanning that respects .gitignore (root and nested)."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Iterator
+
+import pathspec
+
+MAX_FILE_BYTES = 5 * 1024 * 1024  # index.md: never slurp files larger than 5MB
+
+ALWAYS_IGNORE_DIRS = {
+    ".git", ".svn", ".hg", ".ai_context", ".claude", "node_modules", "bin", "obj",
+    "__pycache__", ".vs", ".idea", ".vscode", "dist", "build", ".venv", "venv",
+    "packages", ".pytest_cache", ".mypy_cache",
+}
+
+LANGUAGE_BY_EXT = {
+    ".cs": "csharp",
+    ".py": "python",
+    ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+    ".ts": "typescript", ".tsx": "tsx",
+    ".sql": "sql",
+    # indexed as plain text windows
+    ".vb": "text", ".bas": "text", ".frm": "text", ".cls": "text",
+    ".cshtml": "text", ".aspx": "text", ".asmx": "text", ".vue": "text", ".html": "text",
+    ".css": "text", ".xml": "text", ".config": "text", ".csproj": "text", ".json": "text",
+    ".yml": "text", ".yaml": "text", ".md": "text", ".txt": "text", ".sh": "text",
+    ".ps1": "text", ".ahk": "text", ".iss": "text",
+}
+
+
+@dataclass
+class ScannedFile:
+    rel_path: str  # posix style, relative to root
+    abs_path: str
+    mtime_ns: int
+    size: int
+    language: str
+
+
+def language_for(path: str) -> str | None:
+    return LANGUAGE_BY_EXT.get(os.path.splitext(path)[1].lower())
+
+
+def _ignored(path: str, is_dir: bool, specs: list) -> bool:
+    for base, spec in specs:
+        rel = os.path.relpath(path, base).replace(os.sep, "/")
+        if is_dir:
+            rel += "/"
+        if spec.match_file(rel):
+            return True
+    return False
+
+
+def iter_files(root: str, max_bytes: int = MAX_FILE_BYTES) -> Iterator[ScannedFile]:
+    root = os.path.abspath(root)
+    stack: list[tuple[str, list]] = [(root, [])]
+    while stack:
+        directory, specs = stack.pop()
+        gi = os.path.join(directory, ".gitignore")
+        if os.path.isfile(gi):
+            try:
+                with open(gi, encoding="utf-8", errors="ignore") as f:
+                    specs = specs + [(directory, pathspec.GitIgnoreSpec.from_lines(f.read().splitlines()))]
+            except OSError:
+                pass
+        try:
+            entries = sorted(os.scandir(directory), key=lambda e: e.name)
+        except OSError:
+            continue
+        subdirs = []
+        for e in entries:
+            try:
+                is_dir = e.is_dir(follow_symlinks=False)
+                is_file = e.is_file(follow_symlinks=False)
+            except OSError:
+                continue
+            if is_dir:
+                if e.name in ALWAYS_IGNORE_DIRS or _ignored(e.path, True, specs):
+                    continue
+                subdirs.append((e.path, specs))
+            elif is_file:
+                lang = language_for(e.name)
+                if lang is None or _ignored(e.path, False, specs):
+                    continue
+                try:
+                    st = e.stat()
+                except OSError:
+                    continue
+                if st.st_size > max_bytes:
+                    continue
+                yield ScannedFile(
+                    rel_path=os.path.relpath(e.path, root).replace(os.sep, "/"),
+                    abs_path=e.path,
+                    mtime_ns=st.st_mtime_ns,
+                    size=st.st_size,
+                    language=lang,
+                )
+        stack.extend(reversed(subdirs))

local_codebase_indexer/sqlaccess.py

@@ -0,0 +1,301 @@
+"""T-SQL data access extraction: which tables a piece of SQL reads / writes and which procedures it executes.
+
+This is a lexical analysis (comments and string literals are masked, then statements are matched with
+regular expressions), not a full T-SQL parser. What it does not understand is reported, not guessed:
+
+* dynamic SQL (``EXEC(@sql)``, ``sp_executesql``) becomes an ``uncertain`` access to the unknown object ``?``;
+  string literals inside it are still analysed but also marked ``uncertain``;
+* temp tables (``#t``) and table variables (``@t``) are ignored, as are CTE names and system objects.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+HOLE = "__hole__"  # stands in for interpolated / unknown parts of a C# string
+
+_NAME = r"[#@]?[\w$]+(?:\s*\.\s*[\w$]*){0,3}"
+
+_KEYWORDS = {
+    "select", "from", "where", "set", "values", "as", "on", "default", "exec", "execute", "with", "top",
+    "output", "cascade", "no", "null", "table", "index", "view", "procedure", "function", "trigger", "into",
+    "using", "when", "then", "case", "end", "begin", "inserted", "deleted", "openquery", "openrowset",
+    "openjson", "openxml", "string_split", "generate_series", "and", "or", "not", "is", "in", "if", "else",
+    "all", "any", "distinct", "union", "go", "declare", "return", "the", "a", "an",
+}
+_ALIAS_STOP = _KEYWORDS | {
+    "inner", "left", "right", "full", "cross", "outer", "join", "group", "order", "having", "except",
+    "intersect", "option", "for", "natural", "pivot", "unpivot", "tablesample", "update", "delete", "insert",
+    "merge", "truncate", "while", "print", "raiserror", "commit", "rollback", "throw", "try", "catch",
+}
+_SYSTEM_QUALIFIERS = {"sys", "information_schema"}
+
+_RX_INSERT = re.compile(rf"(?<![@\w$#.])INSERT\s+(?:INTO\s+)?(?P<n>{_NAME})", re.I)
+_RX_UPDATE = re.compile(rf"(?<![@\w$#.])UPDATE\s+(?:TOP\s*\(\s*\d+\s*\)\s+)?(?P<n>{_NAME})\s+SET\b", re.I)
+_RX_DELETE = re.compile(rf"(?<![@\w$#.])DELETE\s+(?:TOP\s*\(\s*\d+\s*\)\s+)?(?:FROM\s+)?(?P<n>{_NAME})", re.I)
+_RX_MERGE = re.compile(rf"(?<![@\w$#.])MERGE\s+(?:TOP\s*\(\s*\d+\s*\)\s+)?(?:INTO\s+)?(?P<n>{_NAME})", re.I)
+_RX_TRUNC = re.compile(rf"(?<![@\w$#.])TRUNCATE\s+TABLE\s+(?P<n>{_NAME})", re.I)
+_RX_INTO = re.compile(rf"(?<![@\w$#.])INTO\s+(?P<n>{_NAME})", re.I)
+_RX_USING = re.compile(rf"(?<![@\w$#.])USING\s+(?P<n>{_NAME})", re.I)
+_RX_FROM = re.compile(r"(?<![@\w$#.])FROM\b", re.I)
+_RX_JOIN = re.compile(r"(?<![@\w$#.])JOIN\b", re.I)
+_RX_EXEC = re.compile(rf"(?<![@\w$#.])EXEC(?:UTE)?\s+(?:@\w+\s*=\s*)?(?P<n>{_NAME})", re.I)
+_RX_EXEC_PAREN = re.compile(r"(?<![@\w$#.])EXEC(?:UTE)?\s*\(", re.I)
+_RX_SPEXEC = re.compile(r"(?<![@\w$#.])sp_executesql\b", re.I)
+_RX_CTE = re.compile(r"(?:\bWITH|,)\s+(?P<n>[\w$]+)\s*(?:\([^)]*\))?\s+AS\s*\(", re.I)
+
+_RX_ITEM_NAME = re.compile(rf"\s*(?P<n>{_NAME})")
+_RX_ALIAS = re.compile(r"\s+(?:AS\s+)?(?P<a>[\w$]+)", re.I)
+_RX_HINT = re.compile(r"\s+WITH\s*\([^)]*\)", re.I)
+_RX_COMMA = re.compile(r"\s*,")
+
+
+@dataclass
+class Access:
+    key: str          # lower-case last name segment; "?" for dynamic SQL
+    name: str         # as written (last segment)
+    qualifier: str    # database / schema / linked server prefix as written
+    kind: str         # table | procedure | function | unknown
+    access: str       # read | write | exec | map
+    op: str           # select | insert | update | delete | merge | truncate | into | exec | dynamic | map
+    line: int
+    via: str          # sql | dynamic_sql | csharp_sql | csharp_sp | ef_mapping
+    confidence: str   # confirmed | probable | uncertain
+    evidence: str = ""
+    detail: str = ""
+    source_id: str | None = None  # symbol that contains the access (set by the caller)
+
+
+def _blank(chars: list[str], start: int, end: int) -> None:
+    for i in range(start, min(end, len(chars))):
+        if chars[i] != "\n":
+            chars[i] = " "
+
+
+def mask_sql(text: str) -> tuple[str, list[tuple[int, int, str]]]:
+    """Blank out comments and string contents (offsets are preserved). Returns the masked text and the
+    string literals as (start, end, content)."""
+    out = list(text)
+    n = len(text)
+    i = 0
+    literals: list[tuple[int, int, str]] = []
+    while i < n:
+        c = text[i]
+        if c == "-" and text.startswith("--", i):
+            j = text.find("\n", i)
+            j = n if j < 0 else j
+            _blank(out, i, j)
+            i = j
+        elif c == "/" and text.startswith("/*", i):
+            j = text.find("*/", i + 2)
+            j = n if j < 0 else j + 2
+            _blank(out, i, j)
+            i = j
+        elif c == "'":
+            j = i + 1
+            while j < n:
+                if text[j] == "'":
+                    if j + 1 < n and text[j + 1] == "'":
+                        j += 2
+                        continue
+                    break
+                j += 1
+            literals.append((i, j, text[i + 1:j].replace("''", "'")))
+            _blank(out, i + 1, j)
+            i = j + 1
+        elif c in '[]"':
+            out[i] = " "
+            i += 1
+        else:
+            i += 1
+    return "".join(out), literals
+
+
+def _split_name(raw: str) -> list[str]:
+    return [p.strip() for p in raw.split(".")]
+
+
+def _acceptable(parts: list[str]) -> bool:
+    last = parts[-1]
+    if not last or last[0] in "#@":
+        return False
+    if last.lower() in _KEYWORDS:
+        return False
+    if len(parts) > 1 and parts[-2].lower() in _SYSTEM_QUALIFIERS:
+        return False
+    return True
+
+
+def _line_of(text: str, pos: int) -> int:
+    return text.count("\n", 0, pos) + 1
+
+
+def _evidence(original: str, pos: int, limit: int = 160) -> str:
+    start = original.rfind("\n", 0, pos) + 1
+    end = original.find("\n", pos)
+    end = len(original) if end < 0 else end
+    return " ".join(original[start:end].split())[:limit]
+
+
+def _parse_items(masked: str, pos: int, allow_list: bool) -> list[tuple[list[str], str | None, bool, int]]:
+    """Table references after FROM / JOIN: [(name parts, alias, is_function, offset)]. With ``allow_list`` a
+    comma separated list (FROM a, b c) is followed."""
+    items = []
+    while True:
+        j = pos
+        while j < len(masked) and masked[j].isspace():
+            j += 1
+        if j >= len(masked) or masked[j] == "(":
+            break  # derived table: its own SELECT is scanned separately
+        m = _RX_ITEM_NAME.match(masked, pos)
+        if not m:
+            break
+        parts = _split_name(m.group("n"))
+        end = m.end()
+        is_func = False
+        k = end
+        while k < len(masked) and masked[k] in " \t":
+            k += 1
+        if k < len(masked) and masked[k] == "(":
+            is_func = True
+            # skip the argument list so a function's arguments are not mistaken for an alias
+            depth = 0
+            while k < len(masked):
+                if masked[k] == "(":
+                    depth += 1
+                elif masked[k] == ")":
+                    depth -= 1
+                    if depth == 0:
+                        k += 1
+                        break
+                k += 1
+            end = k
+        alias = None
+        a = _RX_ALIAS.match(masked, end)
+        if a and a.group("a").lower() not in _ALIAS_STOP:
+            alias = a.group("a")
+            end = a.end()
+        h = _RX_HINT.match(masked, end)
+        if h:
+            end = h.end()
+        items.append((parts, alias, is_func, m.start("n")))
+        pos = end
+        if not allow_list:
+            break
+        c = _RX_COMMA.match(masked, pos)
+        if not c:
+            break
+        pos = c.end()
+    return items
+
+
+def _resolve_alias(target: list[str], window_items: list) -> list[str]:
+    if len(target) != 1:
+        return target
+    low = target[0].lower()
+    for parts, alias, is_func, _ in window_items:
+        if alias and alias.lower() == low and not is_func:
+            return parts
+    return target
+
+
+def extract_sql_accesses(text: str, first_line: int = 1, _dynamic: bool = False) -> list[Access]:
+    """All table / procedure accesses in ``text``; line numbers start at ``first_line``."""
+    masked, literals = mask_sql(text)
+    out: list[Access] = []
+    base_conf = "uncertain" if _dynamic else "confirmed"
+    base_via = "dynamic_sql" if _dynamic else "sql"
+    ctes = {m.group("n").lower() for m in _RX_CTE.finditer(masked)}
+    seen: set[tuple] = set()
+
+    def add(parts: list[str], pos: int, kind: str, access: str, op: str) -> None:
+        if not parts or not _acceptable(parts):
+            return
+        key = parts[-1].lower()
+        if kind == "table" and key in ctes and len(parts) == 1:
+            return
+        conf = base_conf
+        if HOLE in key:
+            parts, key, kind, conf = ["(dynamic)"], "?", "unknown", "uncertain"
+        line = first_line + _line_of(masked, pos) - 1
+        sig = (key, access, op, line)
+        if sig in seen:
+            return
+        seen.add(sig)
+        out.append(Access(
+            key=key, name=parts[-1], qualifier=".".join(parts[:-1]), kind=kind, access=access, op=op, line=line,
+            via=base_via, confidence=conf, evidence=_evidence(text, pos),
+        ))
+
+    def window_items(end: int) -> list:
+        stop = masked.find(";", end)
+        window = masked[end: (stop if 0 <= stop - end < 3000 else end + 3000)]
+        items = []
+        for rx in (_RX_FROM, _RX_JOIN):
+            for m in rx.finditer(window):
+                items.extend(_parse_items(window, m.end(), allow_list=rx is _RX_FROM))
+        return items
+
+    for m in _RX_INSERT.finditer(masked):
+        add(_split_name(m.group("n")), m.start("n"), "table", "write", "insert")
+    for m in _RX_UPDATE.finditer(masked):
+        parts = _resolve_alias(_split_name(m.group("n")), window_items(m.end()))
+        add(parts, m.start("n"), "table", "write", "update")
+    for m in _RX_DELETE.finditer(masked):
+        parts = _resolve_alias(_split_name(m.group("n")), window_items(m.end()))
+        add(parts, m.start("n"), "table", "write", "delete")
+    for m in _RX_MERGE.finditer(masked):
+        add(_split_name(m.group("n")), m.start("n"), "table", "write", "merge")
+        u = _RX_USING.search(masked, m.end(), min(len(masked), m.end() + 3000))
+        if u:
+            add(_split_name(u.group("n")), u.start("n"), "table", "read", "select")
+    for m in _RX_TRUNC.finditer(masked):
+        add(_split_name(m.group("n")), m.start("n"), "table", "write", "truncate")
+    for m in _RX_INTO.finditer(masked):
+        if re.search(r"(?:INSERT|MERGE)\s*(?:TOP\s*\(\s*\d+\s*\)\s*)?$", masked[max(0, m.start() - 40): m.start()], re.I):
+            continue
+        add(_split_name(m.group("n")), m.start("n"), "table", "write", "into")
+
+    for m in _RX_FROM.finditer(masked):
+        if re.search(r"(?<![@\w$#.])DELETE\s+(?:TOP\s*\(\s*\d+\s*\)\s*)?$", masked[max(0, m.start() - 40): m.start()], re.I):
+            continue  # the FROM of DELETE FROM t is the write target, handled above
+        for parts, _alias, is_func, off in _parse_items(masked, m.end(), allow_list=True):
+            add(parts, off, "function" if is_func else "table", "read", "select")
+    for m in _RX_JOIN.finditer(masked):
+        for parts, _alias, is_func, off in _parse_items(masked, m.end(), allow_list=False):
+            add(parts, off, "function" if is_func else "table", "read", "select")
+
+    for m in _RX_EXEC.finditer(masked):
+        parts = _split_name(m.group("n"))
+        if parts[-1].lower() == "sp_executesql":
+            continue
+        if parts[0].startswith("@"):
+            add([HOLE], m.start("n"), "unknown", "exec", "dynamic")
+        else:
+            add(parts, m.start("n"), "procedure", "exec", "exec")
+
+    # dynamic SQL: record the site, and analyse any literal inside the call as uncertain
+    if not _dynamic:
+        dyn_ranges: list[tuple[int, int]] = []
+        for m in list(_RX_EXEC_PAREN.finditer(masked)):
+            depth, k = 1, m.end()
+            while k < len(masked) and depth:
+                depth += (masked[k] == "(") - (masked[k] == ")")
+                k += 1
+            dyn_ranges.append((m.end(), k))
+            add([HOLE], m.start(), "unknown", "exec", "dynamic")
+        for m in _RX_SPEXEC.finditer(masked):
+            dyn_ranges.append((m.end(), min(len(masked), m.end() + 4000)))
+            add([HOLE], m.start(), "unknown", "exec", "dynamic")
+        for start, end in dyn_ranges:
+            for ls, le, content in literals:
+                if start <= ls < end and content.strip():
+                    line = first_line + _line_of(masked, ls) - 1
+                    for a in extract_sql_accesses(content, line, _dynamic=True):
+                        sig = (a.key, a.access, a.op, a.line)
+                        if sig not in seen:
+                            seen.add(sig)
+                            out.append(a)
+    out.sort(key=lambda a: (a.line, a.access, a.key))
+    return out

local_codebase_indexer/synonyms.py

@@ -0,0 +1,101 @@
+"""Cheap domain-term query expansion.
+
+A query that mentions one word of a synonym group also searches the other words of that group, so "SP" finds
+``usp_*`` / ``proc`` code and "預存程序" finds English identifiers. Groups are plain lists: the first entry is
+the canonical English word. A project can extend or override the built-in groups with
+``<root>/.ai_context/synonyms.json``: ``{"groups": [["scrap", "報廢", "ng"]], "disable": ["sp"]}``.
+
+Expansion only adds terms to the keyword / symbol layers and to the text that is embedded; it never removes terms.
+Single-word (ASCII) triggers must match a whole word, CJK triggers match as substrings.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+
+from .db import index_dir
+
+# Generic software + database terms (English <-> zh-TW / zh-CN), then a few common manufacturing words.
+DEFAULT_GROUPS: list[list[str]] = [
+    ["procedure", "sp", "proc", "usp", "stored", "預存程序", "預儲程序", "儲存程序", "存储过程", "预存程序"],
+    ["table", "資料表", "數據表", "数据表", "表格", "資料庫表"],
+    ["view", "檢視表", "視圖", "视图"],
+    ["column", "field", "欄位", "字段", "栏位"],
+    ["database", "db", "資料庫", "数据库"],
+    ["query", "select", "查詢", "查询", "撈資料"],
+    ["insert", "add", "create", "新增", "建立", "添加", "创建"],
+    ["update", "modify", "change", "更新", "修改", "變更", "变更", "異動"],
+    ["delete", "remove", "刪除", "删除", "移除"],
+    ["save", "persist", "store", "儲存", "保存", "存檔"],
+    ["login", "signin", "authenticate", "auth", "登入", "登录", "驗證", "验证", "認證"],
+    ["password", "pwd", "密碼", "密码"],
+    ["user", "account", "使用者", "用戶", "用户", "帳號", "账号"],
+    ["permission", "role", "權限", "权限", "角色"],
+    ["config", "configuration", "settings", "設定", "配置", "组态"],
+    ["connection", "connectionstring", "連線", "连接", "连线"],
+    ["error", "exception", "failure", "錯誤", "错误", "例外", "異常"],
+    ["log", "logging", "紀錄", "記錄", "日誌", "日志"],
+    ["cache", "快取", "缓存"],
+    ["report", "報表", "报表"],
+    ["print", "printer", "列印", "打印", "印表機", "打印机"],
+    ["label", "tag", "標籤", "标签"],
+    ["export", "匯出", "导出"],
+    ["import", "匯入", "导入"],
+    ["test", "unittest", "測試", "测试"],
+    # manufacturing
+    ["lot", "batch", "批號", "批次", "批号"],
+    ["scrap", "報廢", "报废"],
+    ["inspection", "inspect", "檢驗", "檢查", "检验", "检查"],
+    ["defect", "defective", "缺點", "缺陷", "不良"],
+    ["yield", "良率"],
+    ["workorder", "工單", "工单"],
+    ["equipment", "machine", "device", "設備", "机台", "機台", "设备"],
+    ["status", "state", "狀態", "状态"],
+]
+
+_WORD = re.compile(r"[A-Za-z0-9_]+")
+
+
+def _load_project(root: str | None) -> tuple[list[list[str]], set[str]]:
+    if not root:
+        return [], set()
+    path = os.path.join(index_dir(root), "synonyms.json")
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        groups = [[str(w) for w in g] for g in data.get("groups", []) if isinstance(g, list)]
+        return groups, {str(w).lower() for w in data.get("disable", [])}
+    except FileNotFoundError:
+        return [], set()
+    except (OSError, ValueError, AttributeError) as exc:
+        import sys
+        print(f"[indexer] ignoring {path}: {exc}", file=sys.stderr)
+        return [], set()
+
+
+class Expander:
+    def __init__(self, root: str | None = None):
+        extra, disabled = _load_project(root)
+        self.groups = [[w.lower() for w in g] for g in DEFAULT_GROUPS + extra]
+        self.disabled = disabled
+
+    def expand(self, query: str) -> list[str]:
+        """Extra terms (not in the query yet) for every synonym group the query triggers."""
+        low = query.lower()
+        words = set(_WORD.findall(low))
+        words |= {w[:-1] for w in words if len(w) > 3 and w.endswith("s")}  # inserts -> insert
+        extra: list[str] = []
+        for g in self.groups:
+            hit = [w for w in g if w not in self.disabled and
+                   ((w in words) if w.isascii() else (w in low))]
+            if not hit:
+                continue
+            for w in g:
+                if w in self.disabled or w in hit or w in extra:
+                    continue
+                if w.isascii() and w in words:
+                    continue
+                extra.append(w)
+        return extra

local_codebase_indexer-0.2.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: local-codebase-indexer
+Version: 0.2.0
+Summary: Local codebase indexer and context provider for AI coding assistants: MCP server and CLI with SQL data-access and C# call relations. No cloud, no server.
+Author: sfy257000
+Project-URL: Homepage, https://github.com/sfy257000/local-codebase-indexer
+Project-URL: Repository, https://github.com/sfy257000/local-codebase-indexer
+Project-URL: Issues, https://github.com/sfy257000/local-codebase-indexer/issues
+Keywords: mcp,model-context-protocol,claude-code,code-search,semantic-search,codebase-index,tree-sitter,sqlite,stored-procedure,csharp,dapper,t-sql,call-graph,ai-coding-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: tree-sitter>=0.23
+Requires-Dist: tree-sitter-c-sharp
+Requires-Dist: tree-sitter-python
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-typescript
+Requires-Dist: numpy
+Requires-Dist: pathspec
+Provides-Extra: onnx
+Requires-Dist: onnxruntime; extra == "onnx"
+Requires-Dist: tokenizers; extra == "onnx"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Local Codebase Indexer
+
+**English** | [繁體中文](README.zh-TW.md) | [简体中文](README.zh-CN.md)
+
+A local codebase indexer and context provider for AI coding assistants (Claude Code via MCP, GitHub Copilot / Codex via CLI). It helps them navigate large legacy codebases with far fewer tokens. Everything is stored in `.ai_context/indexer.db` inside your project, with no cloud services involved. The design follows [`index.md`](index.md).
+
+## Install
+
+```bash
+pip install local-codebase-indexer              # Python 3.10+
+# or, isolated from your other packages:
+pipx install local-codebase-indexer
+# optional real embeddings (see below): pip install "local-codebase-indexer[onnx]"
+```
+
+From a clone: `pip install -e .` (the `bin/indexer` launcher still works in a checkout).
+
+## Usage (CLI)
+
+```bash
+local-codebase-indexer --root <project> index                       # build / incrementally refresh the index (--force rebuilds all)
+local-codebase-indexer search "database mapping for LotNo" --limit 5
+local-codebase-indexer relations IExistOpenHandleService --direction both   # upstream | downstream | both
+local-codebase-indexer context Services/LotService.cs --lines 120 --padding 15   # alias: slice
+local-codebase-indexer data-access MES_Lot                           # who reads / writes / executes a table or procedure; what a procedure touches
+local-codebase-indexer stats
+local-codebase-indexer status                                       # is the index fresh? failed files, git commit, consistency checks
+```
+
+- Without `--root` the current directory is used; `INDEXER_ROOT` also works.
+- Put `--json` before the subcommand to get JSON output.
+- `search`, `relations` and `context` run an incremental refresh first (mtime check, then md5 only when mtime changed).
+- The tool names from the spec also work as subcommands: `codebase_semantic_search`, `codebase_get_symbol_relations`, `codebase_get_optimized_context` (options `--query`, `--symbol_name --relation_direction`, `--file_path --focus_lines --padding_lines`).
+
+## Usage (Claude Code / MCP)
+
+```bash
+claude mcp add local-indexer -- local-codebase-indexer --root /path/to/project serve
+# without installing: claude mcp add local-indexer -- uvx local-codebase-indexer --root /path/to/project serve
+```
+
+`serve` speaks JSON-RPC (MCP) over stdio and exposes five tools: `codebase_semantic_search`, `codebase_get_symbol_relations`, `codebase_get_optimized_context`, `codebase_get_data_access`, `codebase_index_status`.
+
+## Three-layer index
+
+| Layer | Implementation |
+|---|---|
+| Syntactic | tree-sitter for C#, Python, JavaScript, TypeScript/TSX; regex for SQL (PROCEDURE / VIEW / FUNCTION / TABLE); other text files (VB6 `.frm`, `.config`, `.md`, ...) are split into windowed chunks |
+| Topology | `using` / `import` resolved to file dependencies, inheritance (base lists) and type usage (`invocation`), stored in the `dependencies` table |
+| Semantic | 384-dim chunk embeddings in `vss_chunks`; queries fuse FTS5 keyword, symbol-name and vector rankings with Reciprocal Rank Fusion, then expand to the dependency neighbours of the top 3 files |
+
+Encodings: UTF-8 first, then Big5, then cp1252. Files over 5MB are skipped. Root and nested `.gitignore` files are respected, and `.git`, `bin`, `obj`, `node_modules` and similar directories are always skipped.
+
+## Differences from the spec
+
+- **Vector storage**: `sqlite-vss` needs a native extension and is no longer maintained, so `vss_chunks` stores float32 BLOBs and cosine similarity is computed with numpy. No extension to install.
+- **Embedding model**: the default is a built-in hashing embedder (identifier sub-words, bigrams, CJK character bigrams). It is fast and reproducible but **does not understand synonyms**. For real transformer embeddings, export `all-MiniLM-L6-v2` or `bge-small-en-v1.5` to ONNX, install `onnxruntime` and `tokenizers`, and set `INDEXER_ONNX_MODEL=<folder with model.onnx and tokenizer.json>` (the loading, padding, pooling and re-index logic is covered by a test with a tiny synthetic model; retrieval quality with a real model has not been measured, so run `python benchmarks/run_benchmark.py --compare benchmarks/baseline.json` with the variable set to check it; mean pooling suits MiniLM, bge models recommend CLS pooling). Switching embedders triggers a full re-index.
+- **Call relations** for C# are resolved with limited type inference (using / namespaces, field and constructor-injected types, locals, interface to implementation), and every edge carries a confidence: `confirmed` (the receiver type is known), `probable` (reached through an interface or a single candidate) or `candidate` (name match only). There is no Roslyn: no overload resolution by argument type, no delegates / lambdas / extension methods, and call chains are followed one level. Inheritance edges come from the AST and are reliable.
+- Extra schema additions: `symbols.qualified_name`, `chunk_metadata.symbol_id`, and the `raw_refs`, `chunks_fts` and `meta` tables.
+
+## Data access (SQL)
+
+`data-access <table-or-procedure>` answers "what writes / reads / executes X". It is built from T-SQL (INSERT / UPDATE / DELETE / MERGE / TRUNCATE / SELECT INTO / FROM / JOIN / EXEC, with alias resolution; CTEs, temp tables and system objects excluded), from C# SQL strings (literals, `+`, interpolation, `string.Format`, consts, locals) passed to Dapper, `SqlCommand` or EF `FromSql`, from stored-procedure names used with `CommandType.StoredProcedure`, and from EF `ToTable` / `[Table]` mappings. A procedure's callers are indirect writers of the tables it writes (followed up to 4 hops). Each entry has a confidence; **dynamic SQL (`EXEC(@sql)`, `sp_executesql`, SQL built from unknown values) cannot be resolved and is listed separately as `uncertain`**, never mixed into the confirmed lists. Known gaps: `FROM a JOIN b ON ..., c` loses `c`, and a stored-procedure name passed to a non-database method is not seen.
+
+Natural-language search routes questions such as "who modifies MES_ScrapRecord" or "哪些程式會寫入 MES_Lot" to this index first.
+
+## Query expansion
+
+Queries are expanded with a small synonym dictionary (`SP` / `預存程序` / `stored procedure` / `usp`, table, lot, scrap, ...; `local_codebase_indexer/synonyms.py`). Add or disable groups per project in `.ai_context/synonyms.json`: `{"groups": [["wpnlot", "在製批"]], "disable": ["sp"]}`. This helps abbreviations and Chinese/English terms, not free paraphrase.
+
+## Index health
+
+`status` (also the MCP tool `codebase_index_status`) reports whether the index can be trusted without refreshing it: `fresh`, `stale` (files changed or git HEAD moved since the last update), `degraded` (failed files or an inconsistent database) or `not_indexed`. A file that fails to parse is removed from the index, listed with its error, and retried on every update, so search never returns stale lines for it. `index --force` rebuilds everything.
+
+## Benchmark
+
+`python benchmarks/run_benchmark.py` measures Recall@5, Recall@10 and MRR on fixed queries. See [`benchmarks/README.md`](benchmarks/README.md).
+
+## Tests
+
+```bash
+python -m pytest -q
+```

local_codebase_indexer-0.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+local_codebase_indexer/__init__.py,sha256=_fLYwuAkpHTCaqbaTkrI-oQsQ_QBFIxwL-Xs7r4sRN0,97
+local_codebase_indexer/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+local_codebase_indexer/callgraph.py,sha256=oRkBODqNM1gyGYmSkHODpWTM9a97D9SS2RddWbi4eH0,13256
+local_codebase_indexer/cli.py,sha256=bb0rdfZzHuhRCXGOwrJTsnmN1mkGCrrk5MbOt0dJxNc,5494
+local_codebase_indexer/core.py,sha256=OjUPwkGHobXjWbdNSmEUclyPIznmwhzQCZw62PjfsWQ,13685
+local_codebase_indexer/cscalls.py,sha256=7hIM3sGJwWDEzYLm2PPyGTNtSSRHZV1t_cxc0hvkDzk,13829
+local_codebase_indexer/csdata.py,sha256=ySJhl2ijVNialVtBduPxfxzAv7DZ4Y__r1axiQYXmxE,19587
+local_codebase_indexer/dataflow.py,sha256=lwKWFQo7WraS22-x-dmrlQiFCq84l3vgKhKdTjw8am8,11360
+local_codebase_indexer/db.py,sha256=yGyOBUkbwytYYSyR724RRIQmdxni5gazzYbCWKCLYog,6538
+local_codebase_indexer/embedder.py,sha256=B0KfXHSrlUtY5YURORUnILTgsGWkSQN42wr-LEzXtIs,5401
+local_codebase_indexer/langparse.py,sha256=qussP6Mcl6-NxOBUAnfPjADhpu3ElysJtmWhABToR6g,22162
+local_codebase_indexer/mcp_server.py,sha256=yyJ6KRwbk8XtKS-DyCQhv4wUrCiYDPq2tw2d_kZiiH4,6131
+local_codebase_indexer/query.py,sha256=nYDRWXE3Ef7n0gJu0hIhLCKK4jdwYLQmfbp9Z2ycp9Q,40275
+local_codebase_indexer/scanner.py,sha256=pudhVT1VHxt4vnesabtiqIFignKnIuBx5X5Mf6r0UBw,3458
+local_codebase_indexer/sqlaccess.py,sha256=I_gsKQQrCoiyQ48TZFI_FjO7vCZRNXV292zWALLnKKw,12874
+local_codebase_indexer/synonyms.py,sha256=jVl9Y31p31w43nfYTMwJMjusx7qRuu4bP1nDduGRae4,4601
+local_codebase_indexer-0.2.0.dist-info/METADATA,sha256=TNtriHdPCxoLsHe9Cf_RhYtaLgsoDAnDAeHclOKSMKg,8800
+local_codebase_indexer-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+local_codebase_indexer-0.2.0.dist-info/entry_points.txt,sha256=iqgzZAD66D6YzdgXs1h9XITcIYLbTAqDD3dcGdEKDpU,75
+local_codebase_indexer-0.2.0.dist-info/top_level.txt,sha256=aDUVSeHcu8tffJ5axews940bbBMjYg57yjIrEcBeKq8,23
+local_codebase_indexer-0.2.0.dist-info/RECORD,,

local_codebase_indexer-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

local_codebase_indexer-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+local-codebase-indexer = local_codebase_indexer.cli:main

local_codebase_indexer-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+local_codebase_indexer