@takara-ai/miru-code 0.4.6 → 0.4.10

package/src/mcp/server.ts

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import type { ContentType } from "../types.ts";
-import { formatResults, resolveChunk } from "../utils.ts";
+import { formatResults, localRepoRoot, resolveChunk } from "../utils.ts";
 import { getIndexForRepo, type IndexCache, toolText } from "./index-cache.ts";
 
 const REPO_DESCRIPTION =
@@ -10,11 +10,11 @@ const REPO_DESCRIPTION =
   "The index is built on the first tool call and cached for the session.";
 
 const SERVER_INSTRUCTIONS =
-  "Instant code search for any local or remote git repository. " +
-  "Call `search` to find relevant code; call `find_related` on a result to discover similar code elsewhere. " +
-  "Always pass the project root as `repo` on the first call (local path or https:// git URL). " +
-  "Never guess or infer URLs. " +
-  "Prefer these tools over Grep, Glob, or Read for any question about how code works.";
+  "DO NOT use Grep, Glob, SemanticSearch, or Read to explore code when this server is available. " +
+  "Call `search` first for any question about how code works; call `find_related` on a hit to explore neighbors. " +
+  "Always pass the project root as `repo` (local path or https:// git URL). Never guess URLs. " +
+  "Local repos return `absolute_path` on each hit — use it for Read/edit. " +
+  "Native search is only for exact literal confirmation or files outside the indexed repo.";
 
 export function createMcpServer(cache: IndexCache): McpServer {
   const server = new McpServer(
@@ -31,8 +31,8 @@ export function createMcpServer(cache: IndexCache): McpServer {
     "search",
     {
       description:
-        "Search a codebase with a natural-language or code query. " +
-        "Indexes `repo` on the first call; later calls reuse the session cache.",
+        "DEFAULT code exploration tool. DO NOT use Grep, Glob, SemanticSearch, or Read instead. " +
+        "Search with natural language or a code query. Indexes `repo` on first call; later calls reuse the session cache.",
       inputSchema: {
         query: z.string().describe("Natural language or code query."),
         repo: z.string().describe(REPO_DESCRIPTION),
@@ -46,7 +46,8 @@ export function createMcpServer(cache: IndexCache): McpServer {
         if (results.length === 0) {
           return toolText(JSON.stringify({ error: "No results found." }));
         }
-        return toolText(JSON.stringify(formatResults(query, results)));
+        const repoRoot = localRepoRoot(repo);
+        return toolText(JSON.stringify(formatResults(query, results, { repoRoot })));
       } catch (err) {
         return toolText(err instanceof Error ? err.message : String(err));
       }
@@ -57,13 +58,13 @@ export function createMcpServer(cache: IndexCache): McpServer {
     "find_related",
     {
       description:
-        "Find code chunks semantically similar to a specific location in a file. " +
-        "Use after `search` to explore related implementations or callers.",
+        "Find code similar to a file:line from a prior `search` hit. " +
+        "Use instead of Grep chains or reading whole files to trace related code.",
       inputSchema: {
         file_path: z
           .string()
           .describe(
-            "Path to the file as stored in the index (use file_path from a search result).",
+            "Path from a search hit (`file_path` or `absolute_path` for local repos).",
           ),
         line: z.number().int().describe("Line number (1-indexed)."),
         repo: z.string().describe(REPO_DESCRIPTION),
@@ -73,7 +74,8 @@ export function createMcpServer(cache: IndexCache): McpServer {
     async ({ file_path: filePath, line, repo, top_k: topK }) => {
       try {
         const index = await getIndexForRepo(repo, cache);
-        const chunk = resolveChunk(index.chunks, filePath, line);
+        const repoRoot = localRepoRoot(repo);
+        const chunk = resolveChunk(index.chunks, filePath, line, repoRoot);
         if (!chunk) {
           return toolText(
             `No chunk found at ${filePath}:${line}. Make sure the file is indexed and the line number is within a known chunk.`,
@@ -86,7 +88,9 @@ export function createMcpServer(cache: IndexCache): McpServer {
           );
         }
         return toolText(
-          JSON.stringify(formatResults(`Chunks related to ${filePath}:${line}`, results)),
+          JSON.stringify(
+            formatResults(`Chunks related to ${filePath}:${line}`, results, { repoRoot }),
+          ),
         );
       } catch (err) {
         return toolText(err instanceof Error ? err.message : String(err));

package/src/utils.ts

@@ -1,6 +1,6 @@
-import { resolve } from "node:path";
+import { join, relative, resolve, sep } from "node:path";
 import type { Chunk, ContentType, SearchResult } from "./types.ts";
-import { searchResultToDict } from "./types.ts";
+import { chunkToDict } from "./types.ts";
 
 const GIT_URL_SCHEMES = [
   "https://",
@@ -23,10 +23,38 @@ export function isAllowedRepoSource(repo: string): boolean {
   return repo.startsWith("https://") || repo.startsWith("http://");
 }
 
-export function resolveChunk(chunks: Chunk[], filePath: string, line: number): Chunk | null {
+/** Resolved local repo root for MCP output; null for remote git URLs. */
+export function localRepoRoot(repo: string): string | null {
+  return isGitUrl(repo) ? null : resolve(repo);
+}
+
+/** Map an absolute or repo-relative path to the index-relative form. */
+export function toIndexedFilePath(filePath: string, repoRoot?: string | null): string {
+  if (!repoRoot) {
+    return filePath;
+  }
+  const root = resolve(repoRoot);
+  const candidate = resolve(root, filePath);
+  if (candidate === root) {
+    return "";
+  }
+  const prefix = root.endsWith(sep) ? root : `${root}${sep}`;
+  if (candidate.startsWith(prefix)) {
+    return relative(root, candidate).replace(/\\/g, "/");
+  }
+  return filePath;
+}
+
+export function resolveChunk(
+  chunks: Chunk[],
+  filePath: string,
+  line: number,
+  repoRoot?: string | null,
+): Chunk | null {
+  const indexedPath = toIndexedFilePath(filePath, repoRoot);
   let fallback: Chunk | null = null;
   for (const chunk of chunks) {
-    if (chunk.file_path === filePath && chunk.start_line <= line && line <= chunk.end_line) {
+    if (chunk.file_path === indexedPath && chunk.start_line <= line && line <= chunk.end_line) {
       if (line < chunk.end_line) {
         return chunk;
       }
@@ -38,13 +66,31 @@ export function resolveChunk(chunks: Chunk[], filePath: string, line: number): C
   return fallback;
 }
 
+function chunkToResponseDict(chunk: Chunk, repoRoot?: string | null): Record<string, unknown> {
+  const dict = chunkToDict(chunk);
+  if (!repoRoot) {
+    return dict;
+  }
+  const absolutePath = join(resolve(repoRoot), chunk.file_path);
+  return {
+    ...dict,
+    absolute_path: absolutePath,
+    location: `${absolutePath}:${chunk.start_line}-${chunk.end_line}`,
+  };
+}
+
 export function formatResults(
   query: string,
   results: SearchResult[],
+  options?: { repoRoot?: string | null },
 ): { query: string; results: Record<string, unknown>[] } {
+  const repoRoot = options?.repoRoot ?? null;
   return {
     query,
-    results: results.map(searchResultToDict),
+    results: results.map((result) => ({
+      chunk: chunkToResponseDict(result.chunk, repoRoot),
+      score: result.score,
+    })),
   };
 }