sari 0.0.1__py3-none-any.whl

mcp/tools/registry.py

@@ -0,0 +1,212 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List
+
+import mcp.tools.search as search_tool
+import mcp.tools.status as status_tool
+import mcp.tools.repo_candidates as repo_candidates_tool
+import mcp.tools.list_files as list_files_tool
+import mcp.tools.read_file as read_file_tool
+import mcp.tools.search_symbols as search_symbols_tool
+import mcp.tools.read_symbol as read_symbol_tool
+import mcp.tools.doctor as doctor_tool
+import mcp.tools.search_api_endpoints as search_api_endpoints_tool
+import mcp.tools.index_file as index_file_tool
+import mcp.tools.rescan as rescan_tool
+import mcp.tools.scan_once as scan_once_tool
+import mcp.tools.get_callers as get_callers_tool
+import mcp.tools.get_implementations as get_implementations_tool
+import mcp.tools.deckard_guide as deckard_guide_tool
+
+
+@dataclass
+class ToolContext:
+    db: Any
+    engine: Any
+    indexer: Any
+    roots: List[str]
+    cfg: Any
+    logger: Any
+    workspace_root: str
+    server_version: str
+
+
+@dataclass
+class Tool:
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+    handler: Callable[[ToolContext, Dict[str, Any]], Dict[str, Any]]
+
+
+class ToolRegistry:
+    def __init__(self) -> None:
+        self._tools: Dict[str, Tool] = {}
+
+    def register(self, tool: Tool) -> None:
+        self._tools[tool.name] = tool
+
+    def list_tools(self) -> List[Dict[str, Any]]:
+        return [
+            {"name": t.name, "description": t.description, "inputSchema": t.input_schema}
+            for t in self._tools.values()
+        ]
+
+    def execute(self, name: str, ctx: ToolContext, args: Dict[str, Any]) -> Dict[str, Any]:
+        if name not in self._tools:
+            raise ValueError(f"Unknown tool: {name}")
+        return self._tools[name].handler(ctx, args)
+
+
+def build_default_registry() -> ToolRegistry:
+    reg = ToolRegistry()
+
+    reg.register(Tool(
+        name="sari_guide",
+        description="Usage guide. Call this if unsure; it enforces search-first workflow.",
+        input_schema={"type": "object", "properties": {}},
+        handler=lambda ctx, args: deckard_guide_tool.execute_deckard_guide(args),
+    ))
+
+    reg.register(Tool(
+        name="search",
+        description="SEARCH FIRST. Use before opening files to locate relevant paths/symbols.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Search query (keywords, function names, regex)"},
+                "repo": {"type": "string", "description": "Limit search to specific repository"},
+                "limit": {"type": "integer", "description": "Maximum results (default: 10, max: 50)", "default": 10},
+                "offset": {"type": "integer", "description": "Pagination offset (default: 0)", "default": 0},
+                "file_types": {"type": "array", "items": {"type": "string"}, "description": "Filter by file extensions"},
+                "path_pattern": {"type": "string", "description": "Glob pattern for path matching"},
+                "exclude_patterns": {"type": "array", "items": {"type": "string"}, "description": "Patterns to exclude"},
+                "recency_boost": {"type": "boolean", "description": "Boost recently modified files", "default": False},
+                "use_regex": {"type": "boolean", "description": "Treat query as regex pattern", "default": False},
+                "case_sensitive": {"type": "boolean", "description": "Case-sensitive search", "default": False},
+                "context_lines": {"type": "integer", "description": "Number of context lines in snippet", "default": 5},
+                "total_mode": {"type": "string", "enum": ["exact", "approx"], "description": "Total count mode"},
+                "root_ids": {"type": "array", "items": {"type": "string"}, "description": "Limit search to specific root_ids"},
+                "scope": {"type": "string", "description": "Alias for 'repo'"},
+                "type": {"type": "string", "enum": ["docs", "code"], "description": "Filter by type: 'docs' or 'code'"},
+            },
+            "required": ["query"],
+        },
+        handler=lambda ctx, args: search_tool.execute_search(args, ctx.db, ctx.logger, ctx.roots, engine=ctx.engine),
+    ))
+
+    reg.register(Tool(
+        name="status",
+        description="Get indexer status. Use details=true for per-repo stats.",
+        input_schema={"type": "object", "properties": {"details": {"type": "boolean", "default": False}}},
+        handler=lambda ctx, args: status_tool.execute_status(args, ctx.indexer, ctx.db, ctx.cfg, ctx.workspace_root, ctx.server_version, ctx.logger),
+    ))
+
+    reg.register(Tool(
+        name="rescan",
+        description="Trigger an async rescan of the workspace index.",
+        input_schema={"type": "object", "properties": {}},
+        handler=lambda ctx, args: rescan_tool.execute_rescan(args, ctx.indexer),
+    ))
+
+    reg.register(Tool(
+        name="scan_once",
+        description="Run a synchronous scan once (blocking).",
+        input_schema={"type": "object", "properties": {}},
+        handler=lambda ctx, args: scan_once_tool.execute_scan_once(args, ctx.indexer),
+    ))
+
+    reg.register(Tool(
+        name="repo_candidates",
+        description="Suggest top repos for a query. Use before search if repo is unknown.",
+        input_schema={"type": "object", "properties": {"query": {"type": "string"}, "limit": {"type": "integer", "default": 3}}, "required": ["query"]},
+        handler=lambda ctx, args: repo_candidates_tool.execute_repo_candidates(args, ctx.db, ctx.logger, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="list_files",
+        description="List indexed files with filters. If repo is omitted, returns repo summary only.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "repo": {"type": "string"},
+                "path_pattern": {"type": "string"},
+                "file_types": {"type": "array", "items": {"type": "string"}},
+                "include_hidden": {"type": "boolean", "default": False},
+                "summary": {"type": "boolean", "default": False},
+                "limit": {"type": "integer", "default": 100},
+                "offset": {"type": "integer", "default": 0},
+            },
+        },
+        handler=lambda ctx, args: list_files_tool.execute_list_files(args, ctx.db, ctx.logger, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="read_file",
+        description="Read full file content by path. Use only after search narrows candidates.",
+        input_schema={"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+        handler=lambda ctx, args: read_file_tool.execute_read_file(args, ctx.db, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="search_symbols",
+        description="Search for symbols by name. Prefer this to scanning files.",
+        input_schema={"type": "object", "properties": {"query": {"type": "string"}, "limit": {"type": "integer", "default": 20}}, "required": ["query"]},
+        handler=lambda ctx, args: search_symbols_tool.execute_search_symbols(args, ctx.db, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="read_symbol",
+        description="Read symbol definition block by name/path. Use after search_symbols.",
+        input_schema={"type": "object", "properties": {"path": {"type": "string"}, "name": {"type": "string"}}, "required": ["path", "name"]},
+        handler=lambda ctx, args: read_symbol_tool.execute_read_symbol(args, ctx.db, ctx.logger, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="doctor",
+        description="Run health checks and return structured diagnostics.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "include_network": {"type": "boolean", "default": True},
+                "include_port": {"type": "boolean", "default": True},
+                "include_db": {"type": "boolean", "default": True},
+                "include_disk": {"type": "boolean", "default": True},
+                "include_daemon": {"type": "boolean", "default": True},
+                "include_venv": {"type": "boolean", "default": True},
+                "include_marker": {"type": "boolean", "default": False},
+                "port": {"type": "integer", "default": 47800},
+                "min_disk_gb": {"type": "number", "default": 1.0},
+            },
+        },
+        handler=lambda ctx, args: doctor_tool.execute_doctor(args),
+    ))
+
+    reg.register(Tool(
+        name="search_api_endpoints",
+        description="Search API endpoints by path pattern (search-first for APIs).",
+        input_schema={"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+        handler=lambda ctx, args: search_api_endpoints_tool.execute_search_api_endpoints(args, ctx.db, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="index_file",
+        description="Force immediate re-indexing for a file path. Use when content seems stale.",
+        input_schema={"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
+        handler=lambda ctx, args: index_file_tool.execute_index_file(args, ctx.indexer, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="get_callers",
+        description="Find callers of a symbol (use after search_symbols).",
+        input_schema={"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]},
+        handler=lambda ctx, args: get_callers_tool.execute_get_callers(args, ctx.db, ctx.roots),
+    ))
+
+    reg.register(Tool(
+        name="get_implementations",
+        description="Find implementations of a symbol (use after search_symbols).",
+        input_schema={"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]},
+        handler=lambda ctx, args: get_implementations_tool.execute_get_implementations(args, ctx.db, ctx.roots),
+    ))
+
+    return reg

mcp/tools/repo_candidates.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Repo candidates tool for Sari MCP Server.
+"""
+import json
+from typing import Any, Dict, List
+from mcp.tools._util import mcp_response, pack_header, pack_line, pack_encode_id, pack_encode_text, pack_error, ErrorCode, resolve_root_ids
+
+try:
+    from app.db import LocalSearchDB
+    from mcp.telemetry import TelemetryLogger
+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
+
+
+def execute_repo_candidates(args: Dict[str, Any], db: LocalSearchDB, logger: TelemetryLogger = None, roots: List[str] = None) -> Dict[str, Any]:
+    """Execute repo_candidates tool."""
+    query = args.get("query", "")
+    try:
+        limit_arg = min(int(args.get("limit", 3)), 5)
+    except (ValueError, TypeError):
+        limit_arg = 3
+    
+    if not query.strip():
+        return mcp_response(
+            "repo_candidates",
+            lambda: pack_error("repo_candidates", ErrorCode.INVALID_ARGS, "query is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "query is required"}, "isError": True},
+        )
+    
+    def get_candidates():
+        root_ids = resolve_root_ids(list(roots or []))
+        candidates = db.repo_candidates(q=query, limit=limit_arg, root_ids=root_ids)
+        for candidate in candidates:
+            score = candidate.get("score", 0)
+            if score >= 10:
+                reason = f"High match ({score} files contain '{query}')"
+            elif score >= 5:
+                reason = f"Moderate match ({score} files)"
+            else:
+                reason = f"Low match ({score} files)"
+            candidate["reason"] = reason
+        return candidates
+
+    # --- JSON Builder ---
+    def build_json() -> Dict[str, Any]:
+        candidates = get_candidates()
+        return {
+            "query": query,
+            "candidates": candidates,
+            "hint": "Use 'repo' parameter in search to narrow down scope after selection",
+        }
+
+    # --- PACK1 Builder ---
+    def build_pack() -> str:
+        candidates = get_candidates()
+        
+        # Header
+        kv = {"q": pack_encode_text(query), "limit": limit_arg}
+        lines = [
+            pack_header("repo_candidates", kv, returned=len(candidates))
+        ]
+        
+        # Records
+        for c in candidates:
+            # r:repo=<repo> score=<score> reason=<reason>
+            kv_line = {
+                "repo": pack_encode_id(c["repo"]),
+                "score": str(c["score"]),
+                "reason": pack_encode_text(c["reason"])
+            }
+            lines.append(pack_line("r", kv_line))
+            
+        return "\n".join(lines)
+
+    if logger:
+        # We need candidate count for logging, but don't want to run query twice optimally.
+        # But for simplicity in this structure, we let builders run query. 
+        # Telemetry here might be slightly off if we don't capture result from mcp_response, 
+        # but execute_repo_candidates returns the result, so we can't easily hook in unless we move logging inside builders or after mcp_response.
+        # Let's log *after* mcp_response call by peeking result, or just log query intent.
+        logger.log_telemetry(f"tool=repo_candidates query='{query}' limit={limit_arg}")
+
+    return mcp_response("repo_candidates", build_pack, build_json)

mcp/tools/rescan.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+Rescan tool for Local Search MCP Server.
+"""
+from typing import Any, Dict
+
+from mcp.tools._util import mcp_response, pack_header, pack_line, pack_error, ErrorCode
+
+try:
+    from app.indexer import Indexer
+except ImportError:
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from app.indexer import Indexer
+
+
+def execute_rescan(args: Dict[str, Any], indexer: Indexer) -> Dict[str, Any]:
+    """Trigger async rescan on indexer."""
+    if not indexer:
+        return mcp_response(
+            "rescan",
+            lambda: pack_error("rescan", 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(
+            "rescan",
+            lambda: pack_error("rescan", 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},
+        )
+
+    indexer.request_rescan()
+
+    def build_json() -> Dict[str, Any]:
+        return {"requested": True}
+
+    def build_pack() -> str:
+        lines = [pack_header("rescan", {}, returned=1)]
+        lines.append(pack_line("m", kv={"requested": "true"}))
+        return "\n".join(lines)
+
+    return mcp_response("rescan", build_pack, build_json)

mcp/tools/scan_once.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+Scan-once tool for Local Search MCP Server.
+"""
+from typing import Any, Dict
+
+from mcp.tools._util import mcp_response, pack_header, pack_line, pack_error, ErrorCode
+
+try:
+    from app.indexer import Indexer
+except ImportError:
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from app.indexer import Indexer
+
+
+def execute_scan_once(args: Dict[str, Any], indexer: Indexer) -> Dict[str, Any]:
+    """Run a synchronous scan once."""
+    if not indexer:
+        return mcp_response(
+            "scan_once",
+            lambda: pack_error("scan_once", 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(
+            "scan_once",
+            lambda: pack_error("scan_once", 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},
+        )
+
+    indexer.scan_once()
+    try:
+        scanned = indexer.status.scanned_files
+        indexed = indexer.status.indexed_files
+    except Exception:
+        scanned = 0
+        indexed = 0
+
+    def build_json() -> Dict[str, Any]:
+        return {"ok": True, "scanned_files": scanned, "indexed_files": indexed}
+
+    def build_pack() -> str:
+        lines = [pack_header("scan_once", {}, returned=1)]
+        lines.append(pack_line("m", kv={"ok": "true"}))
+        lines.append(pack_line("m", kv={"scanned_files": str(scanned)}))
+        lines.append(pack_line("m", kv={"indexed_files": str(indexed)}))
+        return "\n".join(lines)
+
+    return mcp_response("scan_once", build_pack, build_json)

mcp/tools/search.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Search tool for Local Search MCP Server (SSOT).
+"""
+import time
+from typing import Any, Dict, List
+
+from mcp.tools._util import (
+    mcp_response,
+    pack_header,
+    pack_line,
+    pack_truncated,
+    pack_encode_id,
+    pack_encode_text,
+    resolve_root_ids,
+    pack_error,
+    ErrorCode,
+)
+
+try:
+    from app.db import LocalSearchDB, SearchOptions
+    from app.engine_runtime import EngineError
+    from mcp.telemetry import TelemetryLogger
+except ImportError:
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from app.db import LocalSearchDB, SearchOptions
+    from app.engine_runtime import EngineError
+    from mcp.telemetry import TelemetryLogger
+
+
+def execute_search(
+    args: Dict[str, Any],
+    db: LocalSearchDB,
+    logger: TelemetryLogger,
+    roots: List[str],
+    engine: Any = None,
+) -> Dict[str, Any]:
+    start_ts = time.time()
+    engine = engine or getattr(db, "engine", None)
+
+    root_ids = resolve_root_ids(roots)
+    req_root_ids = args.get("root_ids")
+    if isinstance(req_root_ids, list):
+        req_root_ids = [str(r) for r in req_root_ids if r]
+        if root_ids:
+            root_ids = [r for r in root_ids if r in req_root_ids]
+        else:
+            root_ids = list(req_root_ids)
+        if req_root_ids and not root_ids:
+            if db and db.has_legacy_paths():
+                root_ids = []
+            else:
+                return mcp_response(
+                    "search",
+                    lambda: pack_error("search", ErrorCode.ERR_ROOT_OUT_OF_SCOPE, "root_ids out of scope", hints=["outside final_roots"]),
+                    lambda: {"error": {"code": ErrorCode.ERR_ROOT_OUT_OF_SCOPE.value, "message": "root_ids out of scope"}, "isError": True},
+                )
+
+    query = (args.get("query") or "").strip()
+    if not query:
+        return mcp_response(
+            "search",
+            lambda: pack_error("search", ErrorCode.INVALID_ARGS, "query is required"),
+            lambda: {"error": {"code": ErrorCode.INVALID_ARGS.value, "message": "query is required"}, "isError": True},
+        )
+
+    repo = args.get("scope") or args.get("repo")
+    if repo == "workspace":
+        repo = None
+
+    file_types = list(args.get("file_types", []))
+    search_type = args.get("type")
+    if search_type == "docs":
+        doc_exts = ["md", "txt", "pdf", "docx", "rst", "pdf"]
+        file_types.extend([e for e in doc_exts if e not in file_types])
+
+    try:
+        limit = int(args.get("limit", 8))
+    except (ValueError, TypeError):
+        limit = 8
+    limit = max(1, min(limit, 50))
+
+    try:
+        offset = max(int(args.get("offset", 0)), 0)
+    except (ValueError, TypeError):
+        offset = 0
+
+    try:
+        raw_lines = int(args.get("context_lines", 5))
+        snippet_lines = min(max(raw_lines, 1), 20)
+    except (ValueError, TypeError):
+        snippet_lines = 5
+
+    total_mode = str(args.get("total_mode") or "").strip().lower()
+    if total_mode not in {"exact", "approx"}:
+        total_mode = "exact"
+
+    engine_mode = "sqlite"
+    index_version = ""
+    if engine and hasattr(engine, "status"):
+        st = engine.status()
+        engine_mode = st.engine_mode
+        index_version = st.index_version
+        if engine_mode == "embedded" and not st.engine_ready:
+            return mcp_response(
+                "search",
+                lambda: pack_error("search", ErrorCode.ERR_ENGINE_UNAVAILABLE, f"engine_ready=false reason={st.reason}", hints=[st.hint] if st.hint else None),
+                lambda: {
+                    "error": {"code": ErrorCode.ERR_ENGINE_UNAVAILABLE.value, "message": f"engine_ready=false reason={st.reason}", "hint": st.hint},
+                    "isError": True,
+                },
+            )
+
+    opts = SearchOptions(
+        query=query,
+        repo=repo,
+        limit=limit,
+        offset=offset,
+        snippet_lines=snippet_lines,
+        file_types=file_types,
+        path_pattern=args.get("path_pattern"),
+        exclude_patterns=args.get("exclude_patterns", []),
+        recency_boost=bool(args.get("recency_boost", False)),
+        use_regex=bool(args.get("use_regex", False)),
+        case_sensitive=bool(args.get("case_sensitive", False)),
+        total_mode=total_mode,
+        root_ids=root_ids,
+    )
+
+    try:
+        hits, meta = engine.search_v2(opts) if engine else ([], {})
+    except EngineError as exc:
+        code = getattr(ErrorCode, exc.code, ErrorCode.ERR_ENGINE_QUERY)
+        return mcp_response(
+            "search",
+            lambda: pack_error("search", code, exc.message, hints=[exc.hint] if exc.hint else None),
+            lambda: {"error": {"code": code.value, "message": exc.message, "hint": exc.hint}, "isError": True},
+        )
+    except Exception as exc:
+        return mcp_response(
+            "search",
+            lambda: pack_error("search", ErrorCode.ERR_ENGINE_QUERY, f"engine query failed: {exc}"),
+            lambda: {"error": {"code": ErrorCode.ERR_ENGINE_QUERY.value, "message": f"engine query failed: {exc}"}, "isError": True},
+        )
+
+    latency_ms = int((time.time() - start_ts) * 1000)
+    total = meta.get("total", -1)
+    total_mode = meta.get("total_mode", total_mode)
+
+    def build_json() -> Dict[str, Any]:
+        results: List[Dict[str, Any]] = []
+        for hit in hits:
+            results.append({
+                "doc_id": hit.path,
+                "repo": hit.repo,
+                "path": hit.path,
+                "score": hit.score,
+                "snippet": hit.snippet,
+                "mtime": hit.mtime,
+                "size": hit.size,
+                "match_count": hit.match_count,
+                "file_type": hit.file_type,
+                "hit_reason": hit.hit_reason,
+                "context_symbol": hit.context_symbol,
+                "docstring": hit.docstring,
+                "metadata": hit.metadata,
+            })
+        return {
+            "query": query,
+            "limit": limit,
+            "offset": offset,
+            "results": results,
+            "meta": {
+                "total": total,
+                "total_mode": total_mode,
+                "engine": engine_mode,
+                "latency_ms": latency_ms,
+                "index_version": index_version,
+            },
+        }
+
+    def build_pack() -> str:
+        returned = len(hits)
+        header = pack_header("search", {"q": pack_encode_text(query)}, returned=returned)
+        lines = [header]
+        lines.append(pack_line("m", {"total": str(total)}))
+        lines.append(pack_line("m", {"total_mode": total_mode}))
+        lines.append(pack_line("m", {"engine": engine_mode}))
+        lines.append(pack_line("m", {"latency_ms": str(latency_ms)}))
+        if index_version:
+            lines.append(pack_line("m", {"index_version": pack_encode_id(index_version)}))
+        for h in hits:
+            lines.append(pack_line("r", {
+                "path": pack_encode_id(h.path),
+                "repo": pack_encode_id(h.repo),
+                "score": f"{h.score:.3f}",
+                "mtime": str(h.mtime),
+                "size": str(h.size),
+                "file_type": pack_encode_id(h.file_type),
+                "snippet": pack_encode_text(h.snippet),
+            }))
+        if returned >= limit:
+            lines.append(pack_truncated(offset + limit, limit, "maybe"))
+        return "\n".join(lines)
+
+    return mcp_response("search", build_pack, build_json)