@takara-ai/miru-code 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",
@@ -61,21 +61,20 @@
     "benchmark:quantization": "bun run scripts/benchmark-quantization.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "ignore": "^7.0.5",
     "web-tree-sitter": "^0.26.9",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.16",
-    "@types/bun": "latest",
+    "@biomejs/biome": "^2.5.1",
+    "@types/bun": "^1.3.14",
     "tree-sitter-bash": "^0.25.1",
     "tree-sitter-c": "^0.24.1",
-    "tree-sitter-c-sharp": "^0.23.1",
+    "tree-sitter-c-sharp": "^0.23.5",
     "tree-sitter-cpp": "^0.23.4",
     "tree-sitter-css": "^0.25.0",
     "tree-sitter-dart": "^1.0.0",
-    "tree-sitter-elixir": "^0.3.4",
+    "tree-sitter-elixir": "^0.3.5",
     "tree-sitter-embedded-template": "^0.25.0",
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-haskell": "^0.23.1",
@@ -84,13 +83,15 @@
     "tree-sitter-javascript": "^0.25.0",
     "tree-sitter-json": "^0.24.8",
     "tree-sitter-ocaml": "^0.24.2",
-    "tree-sitter-php": "^0.23.12",
+    "tree-sitter-php": "^0.24.2",
     "tree-sitter-python": "^0.25.0",
     "tree-sitter-ruby": "^0.23.1",
     "tree-sitter-rust": "^0.24.0",
     "tree-sitter-scala": "^0.24.0",
     "tree-sitter-solidity": "^1.2.13",
     "tree-sitter-typescript": "^0.23.2",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
   }
 }

package/src/mcp/runtime.ts

@@ -0,0 +1,241 @@
+import * as z from "zod";
+import {
+  type JsonRpcError,
+  type JsonRpcId,
+  type JsonRpcMessage,
+  type JsonRpcRequest,
+  type JsonRpcResponse,
+  LATEST_PROTOCOL_VERSION,
+  type StdioTransport,
+  SUPPORTED_PROTOCOL_VERSIONS,
+} from "./stdio.ts";
+
+const JSONRPC_ERROR = {
+  parse: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internal: -32603,
+} as const;
+
+type ToolHandler<Args> = (args: Args) => Promise<{
+  content: Array<{ type: "text"; text: string }>;
+}>;
+
+type RegisteredTool = {
+  description: string;
+  inputSchema: Record<string, z.ZodType>;
+  handler: ToolHandler<Record<string, unknown>>;
+};
+
+export type MiruMcpServerInfo = {
+  name: string;
+  version: string;
+};
+
+export class MiruMcpServer {
+  readonly serverInfo: MiruMcpServerInfo;
+  private readonly instructions?: string;
+  private readonly tools = new Map<string, RegisteredTool>();
+  private transport: StdioTransport | null = null;
+
+  constructor(serverInfo: MiruMcpServerInfo, options?: { instructions?: string }) {
+    this.serverInfo = serverInfo;
+    this.instructions = options?.instructions;
+  }
+
+  registerTool<S extends Record<string, z.ZodType>>(
+    name: string,
+    config: {
+      description: string;
+      inputSchema: S;
+    },
+    handler: ToolHandler<z.infer<z.ZodObject<S>>>,
+  ): void {
+    this.tools.set(name, {
+      description: config.description,
+      inputSchema: config.inputSchema,
+      handler: handler as ToolHandler<Record<string, unknown>>,
+    });
+  }
+
+  async connect(transport: StdioTransport): Promise<void> {
+    this.transport = transport;
+    transport.onmessage = async (message) => {
+      await this.handleMessage(message);
+    };
+    transport.onerror = (error) => {
+      console.error(error);
+    };
+    await transport.start();
+  }
+
+  async close(): Promise<void> {
+    await this.transport?.close();
+    this.transport = null;
+  }
+
+  private async handleMessage(message: JsonRpcMessage): Promise<void> {
+    if (!isRequest(message)) {
+      if (isNotification(message)) {
+        if (message.method === "notifications/initialized") {
+          return;
+        }
+      }
+      return;
+    }
+
+    try {
+      const result = await this.dispatchRequest(message);
+      if (result !== undefined) {
+        await this.send({
+          jsonrpc: "2.0",
+          id: message.id,
+          result,
+        });
+      }
+    } catch (error) {
+      await this.sendError(message.id, error);
+    }
+  }
+
+  private async dispatchRequest(request: JsonRpcRequest): Promise<unknown> {
+    switch (request.method) {
+      case "initialize":
+        return this.handleInitialize(request.params);
+      case "ping":
+        return {};
+      case "tools/list":
+        return { tools: this.listTools() };
+      case "tools/call":
+        return await this.handleToolCall(request.params);
+      default:
+        throw rpcError(JSONRPC_ERROR.methodNotFound, `Method not found: ${request.method}`);
+    }
+  }
+
+  private handleInitialize(params: unknown): Record<string, unknown> {
+    const input = z
+      .object({
+        protocolVersion: z.string(),
+        capabilities: z.record(z.string(), z.unknown()).optional(),
+        clientInfo: z
+          .object({
+            name: z.string(),
+            version: z.string(),
+          })
+          .optional(),
+      })
+      .safeParse(params);
+
+    if (!input.success) {
+      throw rpcError(JSONRPC_ERROR.invalidParams, "Invalid initialize params");
+    }
+
+    const requestedVersion = input.data.protocolVersion;
+    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(
+      requestedVersion as (typeof SUPPORTED_PROTOCOL_VERSIONS)[number],
+    )
+      ? requestedVersion
+      : LATEST_PROTOCOL_VERSION;
+
+    return {
+      protocolVersion,
+      capabilities: this.getCapabilities(),
+      serverInfo: this.serverInfo,
+      ...(this.instructions ? { instructions: this.instructions } : {}),
+    };
+  }
+
+  private getCapabilities(): Record<string, unknown> {
+    if (this.tools.size === 0) {
+      return {};
+    }
+    return {
+      tools: {
+        listChanged: true,
+      },
+    };
+  }
+
+  private listTools(): Array<Record<string, unknown>> {
+    return [...this.tools.entries()].map(([name, tool]) => ({
+      name,
+      description: tool.description,
+      inputSchema: shapeToJsonSchema(tool.inputSchema),
+    }));
+  }
+
+  private async handleToolCall(params: unknown): Promise<Record<string, unknown>> {
+    const input = z
+      .object({
+        name: z.string(),
+        arguments: z.record(z.string(), z.unknown()).optional(),
+      })
+      .safeParse(params);
+
+    if (!input.success) {
+      throw rpcError(JSONRPC_ERROR.invalidParams, "Invalid tools/call params");
+    }
+
+    const tool = this.tools.get(input.data.name);
+    if (!tool) {
+      throw rpcError(JSONRPC_ERROR.invalidParams, `Tool ${input.data.name} not found`);
+    }
+
+    const args = input.data.arguments ?? {};
+    const parsed = z.object(tool.inputSchema).safeParse(args);
+    if (!parsed.success) {
+      throw rpcError(JSONRPC_ERROR.invalidParams, parsed.error.message);
+    }
+
+    return await tool.handler(parsed.data);
+  }
+
+  private async send(message: JsonRpcResponse): Promise<void> {
+    await this.transport?.send(message);
+  }
+
+  private async sendError(id: JsonRpcId, error: unknown): Promise<void> {
+    const rpc = error instanceof RpcError ? error : rpcError(JSONRPC_ERROR.internal, String(error));
+    const message: JsonRpcError = {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: rpc.code,
+        message: rpc.message,
+        ...(rpc.data !== undefined ? { data: rpc.data } : {}),
+      },
+    };
+    await this.transport?.send(message);
+  }
+}
+
+class RpcError extends Error {
+  constructor(
+    readonly code: number,
+    message: string,
+    readonly data?: unknown,
+  ) {
+    super(message);
+    this.name = "RpcError";
+  }
+}
+
+function rpcError(code: number, message: string, data?: unknown): RpcError {
+  return new RpcError(code, message, data);
+}
+
+function isRequest(message: JsonRpcMessage): message is JsonRpcRequest {
+  return "method" in message && "id" in message;
+}
+
+function isNotification(message: JsonRpcMessage): message is { jsonrpc: "2.0"; method: string } {
+  return "method" in message && !("id" in message);
+}
+
+function shapeToJsonSchema(shape: Record<string, z.ZodType>): Record<string, unknown> {
+  const schema = z.toJSONSchema(z.object(shape)) as Record<string, unknown>;
+  const { $schema: _schema, ...rest } = schema;
+  return rest;
+}

package/src/mcp/serve.ts

@@ -1,7 +1,7 @@
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import type { ContentType } from "../types.ts";
 import { IndexCache } from "./index-cache.ts";
 import { createMcpServer } from "./server.ts";
+import { StdioTransport } from "./stdio.ts";
 
 export async function serveMcp(options: {
   ref?: string | null;
@@ -9,6 +9,6 @@ export async function serveMcp(options: {
 }): Promise<void> {
   const cache = new IndexCache(options.content ?? ["code"], options.ref ?? null);
   const server = createMcpServer(cache);
-  const transport = new StdioServerTransport();
+  const transport = new StdioTransport();
   await server.connect(transport);
 }

package/src/mcp/server.ts

@@ -1,4 +1,3 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import packageJson from "../../package.json";
 import {
@@ -20,14 +19,15 @@ import {
   resolveChunk,
 } from "../utils.ts";
 import { getIndexForRepo, type IndexCache, toolText } from "./index-cache.ts";
+import { MiruMcpServer } from "./runtime.ts";
 
 const REPO_DESCRIPTION =
   "https:// or http:// git URL (e.g. https://github.com/org/repo) or local directory path to index and search. " +
   "Pass the project root for local workspaces. " +
   "The index is built on the first tool call and cached for the session.";
 
-export function createMcpServer(cache: IndexCache): McpServer {
-  const server = new McpServer(
+export function createMcpServer(cache: IndexCache): MiruMcpServer {
+  const server = new MiruMcpServer(
     {
       name: "miru",
       version: packageJson.version,

package/src/mcp/stdio.ts

@@ -0,0 +1,111 @@
+export type JsonRpcId = string | number;
+
+export type JsonRpcRequest = {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  method: string;
+  params?: unknown;
+};
+
+export type JsonRpcNotification = {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+};
+
+export type JsonRpcResponse = {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  result?: unknown;
+};
+
+export type JsonRpcError = {
+  jsonrpc: "2.0";
+  id: JsonRpcId;
+  error: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+};
+
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse | JsonRpcError;
+
+export const SUPPORTED_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05",
+  "2024-10-07",
+] as const;
+
+export const LATEST_PROTOCOL_VERSION = SUPPORTED_PROTOCOL_VERSIONS[0];
+
+export class StdioTransport {
+  private buffer = "";
+  private started = false;
+  private abortController: AbortController | null = null;
+
+  onmessage?: (message: JsonRpcMessage) => void | Promise<void>;
+  onerror?: (error: Error) => void;
+  onclose?: () => void;
+
+  async start(): Promise<void> {
+    if (this.started) {
+      throw new Error("StdioTransport already started");
+    }
+    this.started = true;
+    this.abortController = new AbortController();
+    const reader = Bun.stdin.stream().getReader();
+    const decoder = new TextDecoder();
+
+    try {
+      while (!this.abortController.signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        await this.append(decoder.decode(value, { stream: true }));
+      }
+    } catch (error) {
+      if (!this.abortController.signal.aborted) {
+        this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    } finally {
+      reader.releaseLock();
+      this.onclose?.();
+    }
+  }
+
+  async close(): Promise<void> {
+    this.abortController?.abort();
+    this.buffer = "";
+    this.onclose?.();
+  }
+
+  async send(message: JsonRpcMessage): Promise<void> {
+    const line = `${JSON.stringify(message)}\n`;
+    await Bun.write(Bun.stdout, line);
+  }
+
+  private async append(chunk: string): Promise<void> {
+    this.buffer += chunk;
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline === -1) {
+        return;
+      }
+      const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.length === 0) {
+        continue;
+      }
+      try {
+        const message = JSON.parse(line) as JsonRpcMessage;
+        await Promise.resolve(this.onmessage?.(message));
+      } catch (error) {
+        this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+}