sari 0.0.1__py3-none-any.whl

mcp/tools/get_callers.py

@@ -0,0 +1,60 @@
+import json
+from typing import Any, Dict, List
+try:
+    from ._util import mcp_response, pack_header, pack_line, pack_encode_id, pack_encode_text, resolve_root_ids, pack_error, ErrorCode
+except ImportError:
+    from _util import mcp_response, pack_header, pack_line, pack_encode_id, pack_encode_text, resolve_root_ids, pack_error, ErrorCode
+
+def execute_get_callers(args: Dict[str, Any], db: Any, roots: List[str]) -> Dict[str, Any]:
+    """Find symbols that call a specific symbol."""
+    target_symbol = args.get("name", "").strip()
+    if not target_symbol:
+        return mcp_response(
+            "get_callers",
+            lambda: pack_error("get_callers", ErrorCode.INVALID_ARGS, "Symbol name is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "Symbol name is required"}, "isError": True},
+        )
+
+    # Search in symbol_relations table
+    sql = """
+        SELECT from_path, from_symbol, line, rel_type
+        FROM symbol_relations
+        WHERE to_symbol = ?
+        ORDER BY from_path, line
+    """
+    params = [target_symbol]
+    root_ids = resolve_root_ids(roots)
+    if root_ids:
+        root_clause = " OR ".join(["from_path LIKE ?"] * len(root_ids))
+        sql = sql.replace("ORDER BY", f"AND ({root_clause}) ORDER BY")
+        params.extend([f"{rid}/%" for rid in root_ids])
+    
+    with db._read_lock:
+        rows = db._read.execute(sql, params).fetchall()
+
+    results = []
+    for r in rows:
+        results.append({
+            "caller_path": r["from_path"],
+            "caller_symbol": r["from_symbol"],
+            "line": r["line"],
+            "rel_type": r["rel_type"]
+        })
+
+    def build_pack() -> str:
+        lines = [pack_header("get_callers", {"name": pack_encode_text(target_symbol)}, returned=len(results))]
+        for r in results:
+            kv = {
+                "caller_path": pack_encode_id(r["caller_path"]),
+                "caller_symbol": pack_encode_id(r["caller_symbol"]),
+                "line": str(r["line"]),
+                "rel_type": pack_encode_id(r["rel_type"]),
+            }
+            lines.append(pack_line("r", kv))
+        return "\n".join(lines)
+
+    return mcp_response(
+        "get_callers",
+        build_pack,
+        lambda: {"target": target_symbol, "results": results, "count": len(results)},
+    )

mcp/tools/get_implementations.py

@@ -0,0 +1,60 @@
+import json
+from typing import Any, Dict, List
+try:
+    from ._util import mcp_response, pack_header, pack_line, pack_encode_id, pack_encode_text, resolve_root_ids, pack_error, ErrorCode
+except ImportError:
+    from _util import mcp_response, pack_header, pack_line, pack_encode_id, pack_encode_text, resolve_root_ids, pack_error, ErrorCode
+
+def execute_get_implementations(args: Dict[str, Any], db: Any, roots: List[str]) -> Dict[str, Any]:
+    """Find symbols that implement or extend a specific symbol."""
+    target_symbol = args.get("name", "").strip()
+    if not target_symbol:
+        return mcp_response(
+            "get_implementations",
+            lambda: pack_error("get_implementations", ErrorCode.INVALID_ARGS, "Symbol name is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "Symbol name is required"}, "isError": True},
+        )
+
+    # Search in symbol_relations table for implements and extends relations
+    sql = """
+        SELECT from_path, from_symbol, rel_type, line
+        FROM symbol_relations
+        WHERE to_symbol = ? AND (rel_type = 'implements' OR rel_type = 'extends')
+        ORDER BY from_path, line
+    """
+    params = [target_symbol]
+    root_ids = resolve_root_ids(roots)
+    if root_ids:
+        root_clause = " OR ".join(["from_path LIKE ?"] * len(root_ids))
+        sql = sql.replace("ORDER BY", f"AND ({root_clause}) ORDER BY")
+        params.extend([f"{rid}/%" for rid in root_ids])
+    
+    with db._read_lock:
+        rows = db._read.execute(sql, params).fetchall()
+
+    results = []
+    for r in rows:
+        results.append({
+            "implementer_path": r["from_path"],
+            "implementer_symbol": r["from_symbol"],
+            "rel_type": r["rel_type"],
+            "line": r["line"]
+        })
+
+    def build_pack() -> str:
+        lines = [pack_header("get_implementations", {"name": pack_encode_text(target_symbol)}, returned=len(results))]
+        for r in results:
+            kv = {
+                "implementer_path": pack_encode_id(r["implementer_path"]),
+                "implementer_symbol": pack_encode_id(r["implementer_symbol"]),
+                "rel_type": pack_encode_id(r["rel_type"]),
+                "line": str(r["line"]),
+            }
+            lines.append(pack_line("r", kv))
+        return "\n".join(lines)
+
+    return mcp_response(
+        "get_implementations",
+        build_pack,
+        lambda: {"target": target_symbol, "results": results, "count": len(results)},
+    )

mcp/tools/index_file.py

@@ -0,0 +1,75 @@
+import time
+from typing import Any, Dict, List
+
+try:
+    from app.queue_pipeline import FsEvent, FsEventKind
+except Exception:
+    FsEvent = None
+    FsEventKind = None
+
+from mcp.tools._util import mcp_response, pack_error, ErrorCode, resolve_db_path, pack_header, pack_line, pack_encode_id
+
+def execute_index_file(args: Dict[str, Any], indexer: Any, roots: List[str]) -> Dict[str, Any]:
+    """Force immediate re-indexing of a specific file."""
+    path = args.get("path", "").strip()
+    if not path:
+        return mcp_response(
+            "index_file",
+            lambda: pack_error("index_file", ErrorCode.INVALID_ARGS, "File path is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "File path is required"}, "isError": True},
+        )
+
+    if not indexer:
+        return mcp_response(
+            "index_file",
+            lambda: pack_error("index_file", ErrorCode.INTERNAL, "Indexer not available"),
+            lambda: {"error": {"code": ErrorCode.INTERNAL.value, "message": "Indexer not available"}, "isError": True},
+        )
+
+    if not getattr(indexer, "indexing_enabled", True):
+        mode = getattr(indexer, "indexer_mode", "off")
+        code = ErrorCode.ERR_INDEXER_DISABLED if mode == "off" else ErrorCode.ERR_INDEXER_FOLLOWER
+        return mcp_response(
+            "index_file",
+            lambda: pack_error("index_file", code, "Indexer is not available in follower/off mode", fields={"mode": mode}),
+            lambda: {"error": {"code": code.value, "message": "Indexer is not available in follower/off mode", "data": {"mode": mode}}, "isError": True},
+        )
+
+    db_path = resolve_db_path(path, roots)
+    if not db_path:
+        return mcp_response(
+            "index_file",
+            lambda: pack_error("index_file", ErrorCode.ERR_ROOT_OUT_OF_SCOPE, f"Path out of scope: {path}", hints=["outside final_roots"]),
+            lambda: {"error": {"code": ErrorCode.ERR_ROOT_OUT_OF_SCOPE.value, "message": f"Path out of scope: {path}"}, "isError": True},
+        )
+
+    try:
+        fs_path = path
+        if hasattr(indexer, "_decode_db_path"):
+            decoded = indexer._decode_db_path(db_path)  # type: ignore[attr-defined]
+            if decoded:
+                _, fs_path = decoded
+                fs_path = str(fs_path)
+        # Trigger watcher event logic which handles upsert/delete
+        if FsEvent and FsEventKind:
+            evt = FsEvent(kind=FsEventKind.MODIFIED, path=fs_path, dest_path=None, ts=time.time())
+            indexer._process_watcher_event(evt)
+        else:
+            indexer._process_watcher_event(fs_path)
+             
+        def build_pack() -> str:
+            lines = [pack_header("index_file", {}, returned=1)]
+            lines.append(pack_line("m", {"path": pack_encode_id(db_path), "requested": "true"}))
+            return "\n".join(lines)
+
+        return mcp_response(
+            "index_file",
+            build_pack,
+            lambda: {"success": True, "path": db_path, "message": f"Successfully requested re-indexing for {db_path}"},
+        )
+    except Exception as e:
+        return mcp_response(
+            "index_file",
+            lambda: pack_error("index_file", ErrorCode.INTERNAL, str(e)),
+            lambda: {"error": {"code": ErrorCode.INTERNAL.value, "message": str(e)}, "isError": True},
+        )

mcp/tools/list_files.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+List files tool for Local Search MCP Server.
+"""
+import time
+from typing import Any, Dict, List
+
+try:
+    from app.db import LocalSearchDB
+    from mcp.telemetry import TelemetryLogger
+    from mcp.tools._util import mcp_response, pack_header, pack_line, pack_truncated, pack_encode_id, resolve_root_ids
+except ImportError:
+    # Fallback for direct script execution
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from app.db import LocalSearchDB
+    from mcp.telemetry import TelemetryLogger
+    from mcp.tools._util import mcp_response, pack_header, pack_line, pack_truncated, pack_encode_id, resolve_root_ids
+
+
+def execute_list_files(args: Dict[str, Any], db: LocalSearchDB, logger: TelemetryLogger, roots: List[str]) -> Dict[str, Any]:
+    """Execute list_files tool."""
+    start_ts = time.time()
+    root_ids = resolve_root_ids(roots)
+    
+    # Parse args
+    repo = args.get("repo")
+    path_pattern = args.get("path_pattern")
+    file_types = args.get("file_types")
+    include_hidden = bool(args.get("include_hidden", False))
+    try:
+        offset = int(args.get("offset", 0))
+    except (ValueError, TypeError):
+        offset = 0
+        
+    try:
+        limit_arg = int(args.get("limit", 100))
+    except (ValueError, TypeError):
+        limit_arg = 100
+
+    # --- JSON Builder (Legacy) ---
+    def build_json() -> Dict[str, Any]:
+        summary_only = bool(args.get("summary", False)) or (not repo and not path_pattern and not file_types)
+        
+        if summary_only:
+            repo_stats = db.get_repo_stats(root_ids=root_ids)
+            repos = [{"repo": k, "file_count": v} for k, v in repo_stats.items()]
+            repos.sort(key=lambda r: r["file_count"], reverse=True)
+            total = sum(repo_stats.values())
+            return {
+                "files": [],
+                "meta": {
+                    "total": total,
+                    "returned": 0,
+                    "offset": 0,
+                    "limit": 0,
+                    "repos": repos,
+                    "include_hidden": include_hidden,
+                    "mode": "summary",
+                },
+            }
+        else:
+            files, meta = db.list_files(
+                repo=repo,
+                path_pattern=path_pattern,
+                file_types=file_types,
+                include_hidden=include_hidden,
+                limit=limit_arg,
+                offset=offset,
+                root_ids=root_ids,
+            )
+            return {
+                "files": files,
+                "meta": meta,
+            }
+
+    # --- PACK1 Builder ---
+    def build_pack() -> str:
+        # Hard limit for PACK1: 200
+        pack_limit = min(limit_arg, 200)
+        
+        files, meta = db.list_files(
+            repo=repo,
+            path_pattern=path_pattern,
+            file_types=file_types,
+            include_hidden=include_hidden,
+            limit=pack_limit,
+            offset=offset,
+            root_ids=root_ids,
+        )
+        
+        total = meta.get("total", 0)
+        returned = len(files)
+        total_mode = "exact" # list_files usually returns exact counts via DB
+        
+        # Header
+        kv = {
+            "offset": offset,
+            "limit": pack_limit
+        }
+        lines = [
+            pack_header("list_files", kv, returned=returned, total=total, total_mode=total_mode)
+        ]
+        
+        # Records
+        for f in files:
+            # p:<path> (ENC_ID)
+            path_enc = pack_encode_id(f["path"])
+            lines.append(pack_line("p", single_value=path_enc))
+            
+        # Truncation
+        is_truncated = (offset + returned) < total
+        if is_truncated:
+            next_offset = offset + returned
+            lines.append(pack_truncated(next_offset, pack_limit, "true"))
+            
+        return "\n".join(lines)
+
+    # Execute and Telemetry
+    response = mcp_response("list_files", build_pack, build_json)
+    
+    # Telemetry logging
+    latency_ms = int((time.time() - start_ts) * 1000)
+    # Estimate payload size (rough)
+    payload_text = response["content"][0]["text"]
+    payload_bytes = len(payload_text.encode('utf-8'))
+    
+    # Log simplified telemetry
+    repo_val = repo or "all"
+    item_count = payload_text.count('\n') if "PACK1" in payload_text else 0 # Approximation for PACK
+    if "PACK1" not in payload_text:
+         # Rough count for JSON without parsing
+         item_count = payload_text.count('"path":')
+         
+    logger.log_telemetry(f"tool=list_files repo='{repo_val}' items={item_count} payload_bytes={payload_bytes} latency={latency_ms}ms")
+    
+    return response

mcp/tools/read_file.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, List
+from app.db import LocalSearchDB
+from mcp.tools._util import mcp_response, pack_error, ErrorCode, resolve_db_path, pack_header, pack_line, pack_encode_text
+
+def execute_read_file(args: Dict[str, Any], db: LocalSearchDB, roots: List[str]) -> Dict[str, Any]:
+    """
+    Execute read_file tool.
+    
+    Args:
+        args: {"path": str}
+        db: LocalSearchDB instance
+    """
+    path = args.get("path")
+    if not path:
+        return mcp_response(
+            "read_file",
+            lambda: pack_error("read_file", ErrorCode.INVALID_ARGS, "'path' is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "'path' is required"}, "isError": True},
+        )
+
+    db_path = resolve_db_path(path, roots)
+    if not db_path and db.has_legacy_paths():
+        db_path = path
+    if not db_path:
+        return mcp_response(
+            "read_file",
+            lambda: pack_error("read_file", ErrorCode.ERR_ROOT_OUT_OF_SCOPE, f"Path out of scope: {path}", hints=["outside final_roots"]),
+            lambda: {"error": {"code": ErrorCode.ERR_ROOT_OUT_OF_SCOPE.value, "message": f"Path out of scope: {path}"}, "isError": True},
+        )
+
+    content = db.read_file(db_path)
+    if content is None:
+        return mcp_response(
+            "read_file",
+            lambda: pack_error("read_file", ErrorCode.NOT_INDEXED, f"File not found or not indexed: {db_path}"),
+            lambda: {"error": {"code": ErrorCode.NOT_INDEXED.value, "message": f"File not found or not indexed: {db_path}"}, "isError": True},
+        )
+
+    def build_pack() -> str:
+        lines = [pack_header("read_file", {}, returned=1)]
+        lines.append(pack_line("t", single_value=pack_encode_text(content)))
+        return "\n".join(lines)
+
+    return mcp_response(
+        "read_file",
+        build_pack,
+        lambda: {"content": [{"type": "text", "text": content}]},
+    )

mcp/tools/read_symbol.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Read Symbol Tool for Local Search MCP Server.
+Reads only the specific code block (function/class) of a symbol.
+"""
+import json
+import time
+from typing import Any, Dict, List
+
+try:
+    from app.db import LocalSearchDB
+    from mcp.telemetry import TelemetryLogger
+    from mcp.tools._util import mcp_response, pack_error, ErrorCode, resolve_db_path, pack_header, pack_line, pack_encode_text
+except ImportError:
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from app.db import LocalSearchDB
+    from mcp.telemetry import TelemetryLogger
+    from mcp.tools._util import mcp_response, pack_error, ErrorCode, resolve_db_path, pack_header, pack_line, pack_encode_text
+
+
+def execute_read_symbol(args: Dict[str, Any], db: LocalSearchDB, logger: TelemetryLogger, roots: List[str]) -> Dict[str, Any]:
+    """Execute read_symbol tool (v2.7.0)."""
+    start_ts = time.time()
+    
+    path = args.get("path")
+    symbol_name = args.get("name")
+    
+    if not path or not symbol_name:
+        return mcp_response(
+            "read_symbol",
+            lambda: pack_error("read_symbol", ErrorCode.INVALID_ARGS, "'path' and 'name' are required."),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "'path' and 'name' are required."}, "isError": True},
+        )
+
+    db_path = resolve_db_path(path, roots)
+    if not db_path and db.has_legacy_paths():
+        db_path = path
+    if not db_path:
+        return mcp_response(
+            "read_symbol",
+            lambda: pack_error("read_symbol", ErrorCode.ERR_ROOT_OUT_OF_SCOPE, f"Path out of scope: {path}", hints=["outside final_roots"]),
+            lambda: {"error": {"code": ErrorCode.ERR_ROOT_OUT_OF_SCOPE.value, "message": f"Path out of scope: {path}"}, "isError": True},
+        )
+
+    block = db.get_symbol_block(db_path, symbol_name)
+    
+    latency_ms = int((time.time() - start_ts) * 1000)
+    logger.log_telemetry(f"tool=read_symbol path='{path}' name='{symbol_name}' found={bool(block)} latency={latency_ms}ms")
+
+    if not block:
+        return mcp_response(
+            "read_symbol",
+            lambda: pack_error("read_symbol", ErrorCode.NOT_INDEXED, f"Symbol '{symbol_name}' not found in '{db_path}' (or no block range available)."),
+            lambda: {"error": {"code": ErrorCode.NOT_INDEXED.value, "message": f"Symbol '{symbol_name}' not found in '{db_path}' (or no block range available)."}, "isError": True},
+        )
+    
+    # Format output
+    doc = block.get('docstring', '')
+    meta = block.get('metadata', '{}')
+    
+    header = [
+        f"File: {db_path}",
+        f"Symbol: {block['name']}",
+        f"Range: L{block['start_line']} - L{block['end_line']}"
+    ]
+    
+    try:
+        m = json.loads(meta)
+        if m.get("annotations"):
+            header.append(f"Annotations: {', '.join(m['annotations'])}")
+        if m.get("http_path"):
+            header.append(f"API Endpoint: {m['http_path']}")
+    except: pass
+
+    output_lines = [
+        "\n".join(header),
+        "--------------------------------------------------"
+    ]
+    
+    if doc:
+        output_lines.append(f"/* DOCSTRING */\n{doc}\n")
+    
+    output_lines.append(block['content'])
+    output_lines.append("--------------------------------------------------")
+
+    output = "\n".join(output_lines)
+
+    def build_pack() -> str:
+        lines = [pack_header("read_symbol", {}, returned=1)]
+        lines.append(pack_line("t", single_value=pack_encode_text(output)))
+        return "\n".join(lines)
+
+    return mcp_response(
+        "read_symbol",
+        build_pack,
+        lambda: {"content": [{"type": "text", "text": output}]},
+    )