synapse-orch-ai 1.5.0 → 1.5.1

package/backend/core/models.py

@@ -59,7 +59,7 @@ class Repo(BaseModel):
     name: str
     path: str
     description: str = ""
-    included_patterns: list[str] = ["*.py", "*.ts", "*.tsx", "*.js", "*.jsx", "*.rs", "*.go", "*.java", "*.md", "*.html", "*.vue", "*.css", "*.scss", "*.cpp", "*.c"]
+    included_patterns: list[str] = ["*.py", "*.ts", "*.tsx", "*.js", "*.jsx", "*.rs", "*.go", "*.java", "*.md", "*.html", "*.vue", "*.svelte", "*.css", "*.scss", "*.cpp", "*.c"]
     excluded_patterns: list[str] = [".*", "node_modules", "__pycache__", "venv", ".git", "*.pyc"]
     last_indexed: str | None = None
     status: str = "pending" # pending | indexing | indexed | error

package/backend/core/routes/repos.py

@@ -3,11 +3,16 @@ Repo management endpoints (CRUD + reindex).
 """
 import os
 import json
-from fastapi import APIRouter, HTTPException, BackgroundTasks
+from fastapi import APIRouter, HTTPException, BackgroundTasks, Body
+from pydantic import BaseModel
 from core.models import Repo
 from core.config import DATA_DIR, load_settings
 from core.json_store import JsonStore
 
+
+class ReindexOptions(BaseModel):
+    full_reindex: bool = False
+
 router = APIRouter()
 
 _repos_store = JsonStore(os.path.join(DATA_DIR, "repos.json"))
@@ -147,7 +152,8 @@ async def delete_repo(repo_id: str):
     return {"status": "success"}
 
 @router.post("/api/repos/{repo_id}/reindex")
-async def reindex_repo(repo_id: str, background_tasks: BackgroundTasks):
+async def reindex_repo(repo_id: str, background_tasks: BackgroundTasks,
+                       opts: ReindexOptions = Body(default=ReindexOptions())):
     repos = load_repos()
     repo = next((r for r in repos if r["id"] == repo_id), None)
     if not repo:
@@ -174,14 +180,16 @@ async def reindex_repo(repo_id: str, background_tasks: BackgroundTasks):
     # Run in background
     try:
         from services.code_indexer import run_index
-        background_tasks.add_task(run_index, repo_id, real_path, repo["included_patterns"], repo["excluded_patterns"])
+        background_tasks.add_task(run_index, repo_id, real_path,
+                                  repo["included_patterns"], repo["excluded_patterns"],
+                                  opts.full_reindex)
     except ImportError as e:
         print("Indexer unavailable:", e)
         repo["status"] = "error"
         save_repos(repos)
         raise HTTPException(status_code=500, detail="Indexer service not available")
 
-    return {"status": "indexing_started"}
+    return {"status": "indexing_started", "full_reindex": opts.full_reindex}
 
 
 @router.post("/api/repos/{repo_id}/stop-index")

package/backend/core/routes/tools.py

@@ -35,6 +35,21 @@ async def get_custom_tools():
     return load_custom_tools()
 
 
+_NATIVE_SERVER_LABELS: dict[str, str] = {
+    "code_vault_search": "Code Search",
+    "time": "Time & Date",
+    "sql": "SQL Database",
+    "personal_details": "Personal Details",
+    "collect_data": "Collect Data",
+    "pdf_parser": "PDF Parser",
+    "xlsx_parser": "Excel / XLSX",
+    "vault_sandbox": "Vault Sandbox",
+    "web_scraper": "Web Scraper",
+    "bash": "Bash",
+    "Filesystem": "Filesystem",
+}
+
+
 @router.get("/api/tools/available")
 async def get_available_tools():
     """List all available tools from all sources (Native Agents, External MCP, Custom HTTP)"""
@@ -54,7 +69,7 @@ async def get_available_tools():
                 cfg = _server.mcp_manager.get_server_config(server_name)
                 display_label = (cfg.get("label") or server_name) if cfg else server_name
             else:
-                display_label = server_name
+                display_label = _NATIVE_SERVER_LABELS.get(server_name, server_name)
 
             result = await session.list_tools()
             for t in result.tools:

package/backend/core/tools.py

@@ -29,6 +29,10 @@ DEFAULT_TOOLS_BY_TYPE = {
     },
     "code": {
         "search_codebase",
+        "multi_repo_search",
+        "find_similar_code",
+        "list_indexed_files",
+        "get_file_chunks",
     },
     "orchestrator": set(),  # orchestrator agents delegate to sub-agents; no extra tools needed
     "delegate": set(),      # delegate agents route to sub-agents via synthetic delegate_to_agent tool
@@ -90,10 +94,12 @@ async def aggregate_all_tools(agent_sessions, active_agent, custom_tools_list):
                 if tool_name not in allowed_tools:
                     allowed_tools.append(tool_name)
 
-    # Remove search_codebase if embed_code is disabled
+    # Remove embedding tools if embed_code is disabled
     settings = load_settings()
     if not settings.get("embed_code", False):
-        allowed_tools = [t for t in allowed_tools if t != "search_codebase"]
+        _embed_tools = {"search_codebase", "multi_repo_search", "find_similar_code",
+                        "list_indexed_files", "get_file_chunks"}
+        allowed_tools = [t for t in allowed_tools if t not in _embed_tools]
 
     # Standard MCP Tools
     for session_name, session in agent_sessions.items():
@@ -207,6 +213,18 @@ def build_system_prompt(agent_system_template, tools_json, session_id, session_s
     """
     # Determine if code embedding is enabled (for conditional tool description)
     _embed_code = load_settings().get("embed_code", False)
+    _embed_tools_desc = (
+        "- **`search_codebase`** - semantic search within specific repos. Requires `repo_ids`."
+        " Add `file_filter` (e.g. `.py`, `components`) to narrow results.\n"
+        "- **`multi_repo_search`** - like search_codebase but `repo_ids` is optional;"
+        " omit to search ALL indexed repos at once.\n"
+        "- **`find_similar_code`** - pass a code snippet to find similar patterns across repos"
+        " (vs. natural language in search_codebase).\n"
+        "- **`list_indexed_files`** - list every file in the embedding index with chunk counts."
+        " Use before searching to understand coverage.\n"
+        "- **`get_file_chunks`** - retrieve all indexed chunks for a specific file"
+        " (the semantic outline). Use after finding a relevant file."
+    ) if _embed_code else ""
 
     # Get current date/time for context injection
     now = datetime.datetime.now(zoneinfo.ZoneInfo("UTC"))
@@ -279,7 +297,7 @@ You have access to the following tools:
 {tools_json}
 
 **CODE & FILE NAVIGATION:**
-{"- **`search_codebase`** — semantic search across indexed repos. Requires `repo_ids`. Best for broad symbol or concept search." if _embed_code else ""}
+{_embed_tools_desc}
 - **`grep`** — search for a pattern inside a file or across all files in a folder. Pass a file path to search that file, or a folder path to search all files within it. Use `file_pattern` to filter by extension (e.g. `*.py`, `*.ts`).
 - **`glob`** — discover file paths by pattern (e.g. `**/*.py`, `src/**/*.ts`).
 - **`read_file`** — read an entire file. Use when you already know the path and the file is small. For large files, prefer `read_file_by_lines` or `grep`.

package/backend/services/code_indexer.py

@@ -356,6 +356,31 @@ def get_index_status(repo_id: str) -> dict:
         return {"status": "error", "message": str(e), "count": 0}
 
 
+def _get_current_vector_dim(repo_id: str) -> int | None:
+    """Return the vector column dimension currently in the DB, or None if absent."""
+    if not COCOINDEX_AVAILABLE:
+        return None
+    table_name = get_table_name(repo_id)
+    db_url = _get_db_url()
+    if not db_url:
+        return None
+    try:
+        with psycopg.connect(db_url) as conn:
+            with conn.cursor() as cur:
+                cur.execute("""
+                    SELECT atttypmod
+                    FROM pg_attribute
+                    JOIN pg_class ON pg_class.oid = pg_attribute.attrelid
+                    WHERE pg_class.relname = %s
+                      AND pg_attribute.attname = 'embedding'
+                      AND atttypmod > 0
+                """, (table_name,))
+                row = cur.fetchone()
+                return row[0] if row else None
+    except Exception:
+        return None
+
+
 def drop_index(repo_id: str):
     """Drop all tables and CocoIndex metadata for a repo — ensures clean rebuild."""
     if not COCOINDEX_AVAILABLE:
@@ -399,7 +424,7 @@ def _update_repo_status(repo_id: str, **fields):
             json.dump(repos, f, indent=4)
 
 
-def run_index_task(repo_id: str, repo_path: str, included_patterns: list[str], excluded_patterns: list[str]):
+def run_index_task(repo_id: str, repo_path: str, included_patterns: list[str], excluded_patterns: list[str], full_reindex: bool = True):
     if not COCOINDEX_AVAILABLE:
         msg = (
             "CocoIndex not installed in the backend venv — indexing skipped.\n"
@@ -416,11 +441,31 @@ def run_index_task(repo_id: str, repo_path: str, included_patterns: list[str], e
     stop = _stop_events.setdefault(repo_id, threading.Event())
     stop.clear()  # reset from any previous stop request
 
-    print(f"Starting index builder for {repo_id}...")
+    print(f"Starting index builder for {repo_id} (full_reindex={full_reindex})...")
     _update_repo_status(repo_id, status="indexing", error_message=None)
     try:
-        print("[index] Step 0: drop stale tables + CocoIndex metadata")
-        drop_index(repo_id)
+        if full_reindex:
+            print("[index] Step 0: drop stale tables + CocoIndex metadata")
+            drop_index(repo_id)
+        else:
+            # Schema guard: if the embedding dim stored in the DB differs from the currently
+            # configured model's dim, a full rebuild is unavoidable (vector columns are fixed-width).
+            try:
+                model = get_configured_embedding_model()
+                settings = load_settings()
+                dim = probe_embedding_dim(model, settings)
+                current_dim = _get_current_vector_dim(repo_id)
+                if current_dim is not None and current_dim != dim:
+                    print(f"[index] Embedding dim changed ({current_dim} → {dim}), promoting to full reindex")
+                    drop_index(repo_id)
+                    full_reindex = True
+                else:
+                    print("[index] Incremental reindex — tracking table preserved, only changed files will be processed")
+            except Exception as e:
+                print(f"[index] Schema check failed ({e}), falling back to full reindex")
+                drop_index(repo_id)
+                full_reindex = True
+
         if stop.is_set():
             print(f"[index] Stop requested after step 0 — aborting {repo_id}")
             _update_repo_status(repo_id, status="stopped", error_message=None)
@@ -451,7 +496,10 @@ def run_index_task(repo_id: str, repo_path: str, included_patterns: list[str], e
         # update() is a long-running Rust call — we can't interrupt it mid-way,
         # but we check the stop flag immediately after it returns.
         print("[index] Step 4: repo_flow.update()")
-        repo_flow.update(full_reprocess=True)
+        if full_reindex:
+            repo_flow.update(full_reprocess=True)
+        else:
+            repo_flow.update()  # incremental — CocoIndex processes only changed/new files
 
         if stop.is_set():
             print(f"[index] Stop requested — marking {repo_id} as stopped")
@@ -493,10 +541,10 @@ def stop_index(repo_id: str) -> bool:
     return False
 
 
-def run_index(repo_id: str, repo_path: str, included_patterns: list[str], excluded_patterns: list[str]):
+def run_index(repo_id: str, repo_path: str, included_patterns: list[str], excluded_patterns: list[str], full_reindex: bool = True):
     t = threading.Thread(
         target=run_index_task,
-        args=(repo_id, repo_path, included_patterns, excluded_patterns),
+        args=(repo_id, repo_path, included_patterns, excluded_patterns, full_reindex),
         daemon=True,
     )
     _active_threads[repo_id] = t

package/backend/tools/code_search.py

@@ -108,7 +108,20 @@ def _get_table_name(repo_id: str) -> str:
     return f"ci_{repo_id}__emb"
 
 
-async def _search(query: str, repo_ids: list[str], top_k: int = 10) -> list[dict]:
+def _load_indexed_repo_ids() -> list[str]:
+    """Return repo IDs where status == 'indexed' from repos.json."""
+    try:
+        from core.config import DATA_DIR
+        repos_file = os.path.join(DATA_DIR, "repos.json")
+        with open(repos_file) as f:
+            repos = json.load(f)
+        return [r["id"] for r in repos if r.get("status") == "indexed" and r.get("id")]
+    except Exception:
+        return []
+
+
+async def _search(query: str, repo_ids: list[str], top_k: int = 10,
+                  file_filter: str | None = None, min_score: float = 0.0) -> list[dict]:
     """Search indexed repos using cosine similarity."""
     try:
         pool = _get_pool()
@@ -143,13 +156,17 @@ async def _search(query: str, repo_ids: list[str], top_k: int = 10) -> list[dict
 
                     repo_root = repo_path_map.get(repo_id, "")
                     for row in cur.fetchall():
-                        # location may be a psycopg Range object — convert to string
                         loc = row[2]
                         if hasattr(loc, 'lower') and hasattr(loc, 'upper'):
                             loc = f"{loc.lower}-{loc.upper}"
                         else:
                             loc = str(loc) if loc is not None else ""
                         filename = row[0].lstrip("/")
+                        score = round(1.0 - row[3], 5)
+                        if score < min_score:
+                            continue
+                        if file_filter and file_filter not in filename:
+                            continue
                         full_path = f"{repo_root}/{filename}" if repo_root else filename
                         all_results.append({
                             "repo_id": repo_id,
@@ -157,7 +174,7 @@ async def _search(query: str, repo_ids: list[str], top_k: int = 10) -> list[dict
                             "full_path": full_path,
                             "code": row[1],
                             "location": loc,
-                            "score": round(1.0 - row[3], 5)
+                            "score": score,
                         })
                 except Exception as e:
                     err_text = str(e)
@@ -175,6 +192,98 @@ async def _search(query: str, repo_ids: list[str], top_k: int = 10) -> list[dict
     return all_results[:top_k]
 
 
+def _list_files_in_index(repo_id: str, file_filter: str | None = None) -> dict:
+    """Query the embedding table for distinct filenames and chunk counts."""
+    if not _VALID_REPO_ID.match(repo_id):
+        return {"error": f"Invalid repo_id format: {repo_id}"}
+    try:
+        pool = _get_pool()
+    except Exception as e:
+        return {"error": f"Database connection failed: {e}"}
+
+    repo_path_map = _load_repo_paths()
+    repo_root = repo_path_map.get(repo_id, "")
+    table_name = _get_table_name(repo_id)
+
+    try:
+        with pool.connection() as conn:
+            with conn.cursor() as cur:
+                if file_filter:
+                    cur.execute(f"""
+                        SELECT filename, COUNT(*) AS chunk_count
+                        FROM "{table_name}"
+                        WHERE filename LIKE %s
+                        GROUP BY filename
+                        ORDER BY filename
+                    """, (f"%{file_filter}%",))
+                else:
+                    cur.execute(f"""
+                        SELECT filename, COUNT(*) AS chunk_count
+                        FROM "{table_name}"
+                        GROUP BY filename
+                        ORDER BY filename
+                    """)
+                rows = cur.fetchall()
+    except Exception as e:
+        return {"error": f"Query failed for repo '{repo_id}': {e}"}
+
+    files = []
+    total_chunks = 0
+    for row in rows:
+        filename = row[0].lstrip("/")
+        chunk_count = row[1]
+        total_chunks += chunk_count
+        full_path = f"{repo_root}/{filename}" if repo_root else filename
+        files.append({"filename": filename, "chunk_count": chunk_count, "full_path": full_path})
+
+    return {"repo_id": repo_id, "files": files, "total_files": len(files), "total_chunks": total_chunks}
+
+
+def _get_chunks_for_file(repo_id: str, filename: str) -> dict:
+    """Retrieve all indexed chunks for a specific file."""
+    if not _VALID_REPO_ID.match(repo_id):
+        return {"error": f"Invalid repo_id format: {repo_id}"}
+    try:
+        pool = _get_pool()
+    except Exception as e:
+        return {"error": f"Database connection failed: {e}"}
+
+    repo_path_map = _load_repo_paths()
+    repo_root = repo_path_map.get(repo_id, "")
+    table_name = _get_table_name(repo_id)
+    clean_filename = filename.lstrip("/")
+
+    try:
+        with pool.connection() as conn:
+            with conn.cursor() as cur:
+                # Try both with and without leading slash to be robust
+                cur.execute(f"""
+                    SELECT location, code
+                    FROM "{table_name}"
+                    WHERE filename = %s OR filename = %s
+                    ORDER BY location
+                """, (clean_filename, "/" + clean_filename))
+                rows = cur.fetchall()
+    except Exception as e:
+        return {"error": f"Query failed for '{filename}' in repo '{repo_id}': {e}"}
+
+    if not rows:
+        return {"error": f"No chunks found for '{filename}' in repo '{repo_id}'. Use list_indexed_files to see available files."}
+
+    chunks = []
+    for row in rows:
+        loc = row[0]
+        if hasattr(loc, 'lower') and hasattr(loc, 'upper'):
+            loc = f"{loc.lower}-{loc.upper}"
+        else:
+            loc = str(loc) if loc is not None else ""
+        chunks.append({"location": loc, "code": row[1]})
+
+    full_path = f"{repo_root}/{clean_filename}" if repo_root else clean_filename
+    return {"repo_id": repo_id, "filename": clean_filename, "full_path": full_path,
+            "chunks": chunks, "total_chunks": len(chunks)}
+
+
 def _grep_file(
     file_path: str,
     pattern: str,
@@ -397,7 +506,9 @@ async def list_tools() -> list[types.Tool]:
             description=(
                 "Search indexed code repositories for relevant code snippets using semantic vector search. "
                 "Returns matching code with filename, location, and relevance score. "
-                "You MUST provide repo_ids — check the LINKED CODE REPOSITORIES section in your system prompt for available repo IDs."
+                "You MUST provide repo_ids — check the LINKED CODE REPOSITORIES section in your system prompt for available repo IDs. "
+                "Use file_filter to narrow results to a specific path or file type (e.g. 'components', '.py'). "
+                "Use min_score (0–1) to discard low-confidence matches."
             ),
             inputSchema={
                 "type": "object",
@@ -415,11 +526,140 @@ async def list_tools() -> list[types.Tool]:
                         "type": "integer",
                         "description": "Number of results to return (default 10)",
                         "default": 10
+                    },
+                    "file_filter": {
+                        "type": "string",
+                        "description": "Only return results from files whose path contains this string (e.g. 'src/api', '.py', 'components')"
+                    },
+                    "min_score": {
+                        "type": "number",
+                        "description": "Minimum relevance score 0–1 (default 0.0 — return all). Higher values (e.g. 0.7) return only strong matches.",
+                        "default": 0.0
                     }
                 },
                 "required": ["query", "repo_ids"]
             },
         ),
+        types.Tool(
+            name="multi_repo_search",
+            description=(
+                "Search across multiple indexed repos simultaneously and return globally ranked results. "
+                "Unlike search_codebase, repo_ids is optional — if omitted, ALL indexed repos are searched automatically. "
+                "Use this when you don't know which repo contains the code you're looking for, or want the best match anywhere. "
+                "Use file_filter to narrow to a specific path or file type."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Natural language or code search query"
+                    },
+                    "repo_ids": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Repos to search. Omit or pass an empty list to search ALL indexed repos."
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Total results to return across all repos (default 10)",
+                        "default": 10
+                    },
+                    "file_filter": {
+                        "type": "string",
+                        "description": "Only return results from files whose path contains this string"
+                    },
+                    "min_score": {
+                        "type": "number",
+                        "description": "Minimum relevance score 0–1 (default 0.0)",
+                        "default": 0.0
+                    }
+                },
+                "required": ["query"]
+            },
+        ),
+        types.Tool(
+            name="find_similar_code",
+            description=(
+                "Given a code snippet, find semantically similar code patterns across one or more repos. "
+                "Unlike search_codebase (which takes natural language), this embeds actual code — "
+                "use it when you have a piece of code and want to find similar implementations or usages elsewhere. "
+                "repo_ids is optional; omit to search all indexed repos."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "code": {
+                        "type": "string",
+                        "description": "A code snippet to find similar patterns for"
+                    },
+                    "repo_ids": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Repos to search. Omit to search all indexed repos."
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Number of results to return (default 10)",
+                        "default": 10
+                    },
+                    "file_filter": {
+                        "type": "string",
+                        "description": "Only return results from files whose path contains this string"
+                    },
+                    "min_score": {
+                        "type": "number",
+                        "description": "Minimum relevance score 0–1 (default 0.0)",
+                        "default": 0.0
+                    }
+                },
+                "required": ["code"]
+            },
+        ),
+        types.Tool(
+            name="list_indexed_files",
+            description=(
+                "List all files that have been embedded in the vector index for a repo, with their chunk counts. "
+                "Use this to discover what's covered by the index before searching, or to verify a specific file was indexed. "
+                "Optionally filter by file path substring."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_id": {
+                        "type": "string",
+                        "description": "The repo ID to list indexed files for"
+                    },
+                    "file_filter": {
+                        "type": "string",
+                        "description": "Only show files whose path contains this string (e.g. 'src/', '.py')"
+                    }
+                },
+                "required": ["repo_id"]
+            },
+        ),
+        types.Tool(
+            name="get_file_chunks",
+            description=(
+                "Get all embedded chunks for a specific file — the semantic view of that file as seen by the index. "
+                "After finding a relevant file via search_codebase, use this to retrieve all its indexed segments "
+                "and understand the full scope of what's embedded, without reading the raw file."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_id": {
+                        "type": "string",
+                        "description": "The repo ID the file belongs to"
+                    },
+                    "filename": {
+                        "type": "string",
+                        "description": "Relative file path as returned by search_codebase (e.g. 'src/auth/login.py')"
+                    }
+                },
+                "required": ["repo_id", "filename"]
+            },
+        ),
         types.Tool(
             name="grep",
             description=(
@@ -496,13 +736,67 @@ async def call_tool(
             query = arguments.get("query", "")
             repo_ids = arguments.get("repo_ids", [])
             top_k = arguments.get("top_k", 10)
+            file_filter = arguments.get("file_filter") or None
+            min_score = float(arguments.get("min_score", 0.0))
 
             if not query or not repo_ids:
                 return [types.TextContent(type="text", text=json.dumps({"error": "Both 'query' and 'repo_ids' are required."}))]
 
-            results = await _search(query, repo_ids, top_k)
+            results = await _search(query, repo_ids, top_k, file_filter=file_filter, min_score=min_score)
             return [types.TextContent(type="text", text=json.dumps({"results": results}, ensure_ascii=False))]
 
+        if name == "multi_repo_search":
+            query = arguments.get("query", "")
+            if not query:
+                return [types.TextContent(type="text", text=json.dumps({"error": "'query' is required."}))]
+
+            repo_ids = arguments.get("repo_ids") or []
+            if not repo_ids:
+                repo_ids = _load_indexed_repo_ids()
+                if not repo_ids:
+                    return [types.TextContent(type="text", text=json.dumps({"error": "No indexed repos found. Index a repo first."}))]
+
+            top_k = arguments.get("top_k", 10)
+            file_filter = arguments.get("file_filter") or None
+            min_score = float(arguments.get("min_score", 0.0))
+
+            results = await _search(query, repo_ids, top_k, file_filter=file_filter, min_score=min_score)
+            return [types.TextContent(type="text", text=json.dumps({"results": results, "repos_searched": repo_ids}, ensure_ascii=False))]
+
+        if name == "find_similar_code":
+            code = arguments.get("code", "")
+            if not code:
+                return [types.TextContent(type="text", text=json.dumps({"error": "'code' is required."}))]
+
+            repo_ids = arguments.get("repo_ids") or []
+            if not repo_ids:
+                repo_ids = _load_indexed_repo_ids()
+                if not repo_ids:
+                    return [types.TextContent(type="text", text=json.dumps({"error": "No indexed repos found. Index a repo first."}))]
+
+            top_k = arguments.get("top_k", 10)
+            file_filter = arguments.get("file_filter") or None
+            min_score = float(arguments.get("min_score", 0.0))
+
+            results = await _search(code, repo_ids, top_k, file_filter=file_filter, min_score=min_score)
+            return [types.TextContent(type="text", text=json.dumps({"results": results, "repos_searched": repo_ids}, ensure_ascii=False))]
+
+        if name == "list_indexed_files":
+            repo_id = arguments.get("repo_id", "")
+            if not repo_id:
+                return [types.TextContent(type="text", text=json.dumps({"error": "'repo_id' is required."}))]
+            file_filter = arguments.get("file_filter") or None
+            result = _list_files_in_index(repo_id, file_filter=file_filter)
+            return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+        if name == "get_file_chunks":
+            repo_id = arguments.get("repo_id", "")
+            filename = arguments.get("filename", "")
+            if not repo_id or not filename:
+                return [types.TextContent(type="text", text=json.dumps({"error": "Both 'repo_id' and 'filename' are required."}))]
+            result = _get_chunks_for_file(repo_id, filename)
+            return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
         if name == "grep":
             # Accept both new `path` and legacy `file_path` for backward compatibility
             path = arguments.get("path") or arguments.get("file_path")

package/frontend-build/.next/BUILD_ID

@@ -1 +1 @@
-47MXNuH5FrJAfrk7sJf9l
+yEEl_TTPPEzHJlgKg21Go

package/frontend-build/.next/build-manifest.json

@@ -7,9 +7,9 @@
     "static/chunks/03~yq9q893hmn.js"
   ],
   "lowPriorityFiles": [
-    "static/47MXNuH5FrJAfrk7sJf9l/_buildManifest.js",
-    "static/47MXNuH5FrJAfrk7sJf9l/_ssgManifest.js",
-    "static/47MXNuH5FrJAfrk7sJf9l/_clientMiddlewareManifest.js"
+    "static/yEEl_TTPPEzHJlgKg21Go/_buildManifest.js",
+    "static/yEEl_TTPPEzHJlgKg21Go/_ssgManifest.js",
+    "static/yEEl_TTPPEzHJlgKg21Go/_clientMiddlewareManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/0qmh881w772ef.js",

package/frontend-build/.next/prerender-manifest.json

@@ -131,8 +131,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "a0c0e723631d4645cff9560c0e471540",
-    "previewModeSigningKey": "afd1ef141acca6335fa57541b914fbf175e0791f4e33dc44ea89dcae8517e371",
-    "previewModeEncryptionKey": "bb4cfb0c917fd8eb580d0e14c92f71ac59af18f950aa75fbd4ea97c0e98ecf14"
+    "previewModeId": "bc368afe07caae8bf169c8234849e882",
+    "previewModeSigningKey": "190f16e9b88e7771194d70cdf5e69441824646affcdc450555fd563eed084faa",
+    "previewModeEncryptionKey": "a2688049a98d936f285726f270987cb712966062a8078f5f90eb21aa28b36b66"
   }
 }