@winci/local-rag 0.2.1

package/src/search/eval.ts

@@ -0,0 +1,171 @@
+import { readFile, writeFile } from "fs/promises";
+import { resolve, basename } from "path";
+import { RagDB } from "../db";
+import { search, type DedupedResult } from "./hybrid";
+import { loadConfig } from "../config";
+
+export interface EvalTask {
+  task: string;
+  grading: string; // human-readable criteria for what a good answer looks like
+  expectedFiles?: string[]; // optional: files the agent should reference
+}
+
+export interface EvalTrace {
+  task: string;
+  grading: string;
+  condition: "with-rag" | "without-rag";
+  searchResults: DedupedResult[];
+  filesReferenced: string[];
+  searchCount: number;
+  durationMs: number;
+}
+
+export interface EvalSummary {
+  totalTasks: number;
+  withRag: {
+    avgSearchResults: number;
+    avgFilesReferenced: number;
+    avgDurationMs: number;
+    fileHitRate: number; // % of tasks where expected files were found
+  };
+  withoutRag: {
+    avgSearchResults: number;
+    avgFilesReferenced: number;
+    avgDurationMs: number;
+    fileHitRate: number;
+  };
+  traces: EvalTrace[];
+}
+
+export async function loadEvalTasks(path: string): Promise<EvalTask[]> {
+  const raw = await readFile(path, "utf-8");
+  const parsed = JSON.parse(raw);
+
+  if (!Array.isArray(parsed)) {
+    throw new Error("Eval file must be a JSON array of { task, grading } objects");
+  }
+
+  for (const entry of parsed) {
+    if (!entry.task || !entry.grading) {
+      throw new Error(`Invalid eval entry: ${JSON.stringify(entry)}. Each entry needs "task" (string) and "grading" (string)`);
+    }
+  }
+
+  return parsed;
+}
+
+/**
+ * Simulate an agent's search behavior for a task.
+ * "with-rag": runs semantic search on the task description and returns what was found.
+ * "without-rag": returns empty results (simulating an agent with no RAG).
+ */
+export async function runEvalTask(
+  task: EvalTask,
+  db: RagDB,
+  projectDir: string,
+  condition: "with-rag" | "without-rag",
+  topK: number = 5
+): Promise<EvalTrace> {
+  const start = performance.now();
+  let searchResults: DedupedResult[] = [];
+  let searchCount = 0;
+
+  if (condition === "with-rag") {
+    const config = await loadConfig(projectDir);
+    searchResults = await search(task.task, db, topK, 0, config.hybridWeight);
+    searchCount = 1;
+  }
+
+  const durationMs = Math.round(performance.now() - start);
+  const filesReferenced = searchResults.map((r) => r.path);
+
+  return {
+    task: task.task,
+    grading: task.grading,
+    condition,
+    searchResults,
+    filesReferenced,
+    searchCount,
+    durationMs,
+  };
+}
+
+export async function runEval(
+  tasks: EvalTask[],
+  db: RagDB,
+  projectDir: string,
+  topK: number = 5
+): Promise<EvalSummary> {
+  const traces: EvalTrace[] = [];
+
+  for (const task of tasks) {
+    const withRag = await runEvalTask(task, db, projectDir, "with-rag", topK);
+    const withoutRag = await runEvalTask(task, db, projectDir, "without-rag", topK);
+    traces.push(withRag, withoutRag);
+  }
+
+  const withRagTraces = traces.filter((t) => t.condition === "with-rag");
+  const withoutRagTraces = traces.filter((t) => t.condition === "without-rag");
+
+  function computeStats(traceSet: EvalTrace[], tasks: EvalTask[]) {
+    const n = traceSet.length || 1;
+    const avgSearchResults = traceSet.reduce((s, t) => s + t.searchResults.length, 0) / n;
+    const avgFilesReferenced = traceSet.reduce((s, t) => s + t.filesReferenced.length, 0) / n;
+    const avgDurationMs = traceSet.reduce((s, t) => s + t.durationMs, 0) / n;
+
+    // File hit rate: % of tasks with expectedFiles where at least one was found
+    let hits = 0;
+    let withExpected = 0;
+    for (let i = 0; i < tasks.length; i++) {
+      if (tasks[i].expectedFiles && tasks[i].expectedFiles!.length > 0) {
+        withExpected++;
+        const expected = tasks[i].expectedFiles!;
+        const found = traceSet[i].filesReferenced;
+        const hasHit = expected.some((e) =>
+          found.some((f) => f === e || f.endsWith(e) || e.endsWith(f))
+        );
+        if (hasHit) hits++;
+      }
+    }
+    const fileHitRate = withExpected > 0 ? hits / withExpected : 0;
+
+    return { avgSearchResults, avgFilesReferenced, avgDurationMs, fileHitRate };
+  }
+
+  return {
+    totalTasks: tasks.length,
+    withRag: computeStats(withRagTraces, tasks),
+    withoutRag: computeStats(withoutRagTraces, tasks),
+    traces,
+  };
+}
+
+export function formatEvalReport(summary: EvalSummary): string {
+  const lines: string[] = [];
+
+  lines.push(`A/B Eval results (${summary.totalTasks} tasks):`);
+  lines.push("");
+  lines.push("                     With RAG    Without RAG");
+  lines.push(`  Avg results:       ${summary.withRag.avgSearchResults.toFixed(1).padStart(8)}    ${summary.withoutRag.avgSearchResults.toFixed(1).padStart(11)}`);
+  lines.push(`  Avg files found:   ${summary.withRag.avgFilesReferenced.toFixed(1).padStart(8)}    ${summary.withoutRag.avgFilesReferenced.toFixed(1).padStart(11)}`);
+  lines.push(`  File hit rate:     ${(summary.withRag.fileHitRate * 100).toFixed(0).padStart(7)}%    ${(summary.withoutRag.fileHitRate * 100).toFixed(0).padStart(10)}%`);
+  lines.push(`  Avg latency:       ${summary.withRag.avgDurationMs.toFixed(0).padStart(7)}ms    ${summary.withoutRag.avgDurationMs.toFixed(0).padStart(10)}ms`);
+
+  // Per-task breakdown
+  lines.push("\nPer-task breakdown:");
+  const withRagTraces = summary.traces.filter((t) => t.condition === "with-rag");
+  for (const trace of withRagTraces) {
+    const files = trace.filesReferenced.length > 0
+      ? trace.filesReferenced.map((f) => basename(f)).join(", ")
+      : "(none)";
+    lines.push(`  "${trace.task}"`);
+    lines.push(`    files found: ${files}`);
+    lines.push(`    grading: ${trace.grading}`);
+  }
+
+  return lines.join("\n");
+}
+
+export async function saveEvalTraces(traces: EvalTrace[], outputPath: string): Promise<void> {
+  await writeFile(outputPath, JSON.stringify(traces, null, 2));
+}

package/src/search/hybrid.ts

@@ -0,0 +1,194 @@
+import { embed } from "../embeddings/embed";
+import { RagDB, type SearchResult, type ChunkSearchResult } from "../db";
+import { rerank } from "./reranker";
+import { log } from "../utils/log";
+
+export interface DedupedResult {
+  path: string;
+  score: number;
+  snippets: string[];
+}
+
+export interface ChunkResult {
+  path: string;
+  score: number;
+  content: string;
+  chunkIndex: number;
+  entityName: string | null;
+  chunkType: string | null;
+  startLine: number | null;
+  endLine: number | null;
+}
+
+// Default: 70% vector, 30% BM25
+const DEFAULT_HYBRID_WEIGHT = 0.7;
+
+/**
+ * Merge vector and text search results using hybrid scoring.
+ * Each result must have `score`, `path`, and `chunkIndex` at minimum.
+ * Extra fields from the vector results are preserved on the merged output.
+ */
+export function mergeHybridScores<T extends { score: number; path: string; chunkIndex: number }>(
+  vectorResults: T[],
+  textResults: T[],
+  hybridWeight: number
+): T[] {
+  const scoreMap = new Map<string, { item: T; vectorScore: number; textScore: number }>();
+
+  for (const r of vectorResults) {
+    const key = `${r.path}:${r.chunkIndex}`;
+    scoreMap.set(key, { item: r, vectorScore: r.score, textScore: 0 });
+  }
+
+  for (const r of textResults) {
+    const key = `${r.path}:${r.chunkIndex}`;
+    const existing = scoreMap.get(key);
+    if (existing) {
+      existing.textScore = r.score;
+    } else {
+      scoreMap.set(key, { item: r, vectorScore: 0, textScore: r.score });
+    }
+  }
+
+  return Array.from(scoreMap.values()).map((entry) => ({
+    ...entry.item,
+    score: hybridWeight * entry.vectorScore + (1 - hybridWeight) * entry.textScore,
+  }));
+}
+
+export async function search(
+  query: string,
+  db: RagDB,
+  topK: number = 5,
+  threshold: number = 0,
+  hybridWeight: number = DEFAULT_HYBRID_WEIGHT,
+  enableReranking: boolean = false
+): Promise<DedupedResult[]> {
+  const start = performance.now();
+  const queryEmbedding = await embed(query);
+
+  // Fetch more than topK to allow deduplication
+  const vectorResults = db.search(queryEmbedding, topK * 3);
+
+  // BM25 text search for keyword matching
+  let textResults: typeof vectorResults = [];
+  try {
+    textResults = db.textSearch(query, topK * 3);
+  } catch (err) {
+    log.debug(`FTS query failed, falling back to vector-only: ${err instanceof Error ? err.message : err}`, "search");
+  }
+
+  const merged = mergeHybridScores(vectorResults, textResults, hybridWeight);
+
+  // Deduplicate by file path, keeping the best score per file
+  const byFile = new Map<string, DedupedResult>();
+
+  for (const result of merged) {
+    if (threshold > 0 && result.score < threshold) continue;
+
+    const existing = byFile.get(result.path);
+    if (existing) {
+      if (result.score > existing.score) {
+        existing.score = result.score;
+      }
+      if (!existing.snippets.includes(result.snippet)) {
+        existing.snippets.push(result.snippet);
+      }
+    } else {
+      byFile.set(result.path, {
+        path: result.path,
+        score: result.score,
+        snippets: [result.snippet],
+      });
+    }
+  }
+
+  // Sort by score descending, take candidates for reranking
+  let results = Array.from(byFile.values())
+    .sort((a, b) => b.score - a.score)
+    .slice(0, enableReranking ? topK * 2 : topK);
+
+  // Cross-encoder reranking: re-score top candidates for precision
+  if (enableReranking && results.length > 0) {
+    try {
+      const passages = results.map((r) => r.snippets[0] ?? "");
+      const rerankScores = await rerank(query, passages);
+      results = results
+        .map((r, i) => ({ ...r, score: rerankScores[i] }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+    } catch (err) {
+      log.warn(`Reranking failed, using hybrid scores: ${err instanceof Error ? err.message : err}`, "search");
+      results = results.slice(0, topK);
+    }
+  }
+
+  // Log query for analytics
+  const durationMs = Math.round(performance.now() - start);
+  db.logQuery(
+    query,
+    results.length,
+    results[0]?.score ?? null,
+    results[0]?.path ?? null,
+    durationMs
+  );
+
+  return results;
+}
+
+/**
+ * Chunk-level search: returns individual semantic chunks ranked by relevance.
+ * No file deduplication — two chunks from the same file can both appear.
+ */
+export async function searchChunks(
+  query: string,
+  db: RagDB,
+  topK: number = 8,
+  threshold: number = 0.3,
+  hybridWeight: number = DEFAULT_HYBRID_WEIGHT,
+  enableReranking: boolean = false
+): Promise<ChunkResult[]> {
+  const start = performance.now();
+  const queryEmbedding = await embed(query);
+
+  const vectorResults = db.searchChunks(queryEmbedding, topK * 3);
+
+  let textResults: ChunkSearchResult[] = [];
+  try {
+    textResults = db.textSearchChunks(query, topK * 3);
+  } catch (err) {
+    log.debug(`FTS chunk query failed, falling back to vector-only: ${err instanceof Error ? err.message : err}`, "search");
+  }
+
+  let results = mergeHybridScores(vectorResults, textResults, hybridWeight)
+    .filter((r) => r.score >= threshold)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, enableReranking ? topK * 2 : topK);
+
+  // Cross-encoder reranking: re-score top candidates for precision
+  if (enableReranking && results.length > 0) {
+    try {
+      const passages = results.map((r) => r.content);
+      const rerankScores = await rerank(query, passages);
+      results = results
+        .map((r, i) => ({ ...r, score: rerankScores[i] }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+    } catch (err) {
+      log.warn(`Reranking failed, using hybrid scores: ${err instanceof Error ? err.message : err}`, "search");
+      results = results.slice(0, topK);
+    }
+  }
+
+  // Log query for analytics
+  const durationMs = Math.round(performance.now() - start);
+  db.logQuery(
+    query,
+    results.length,
+    results[0]?.score ?? null,
+    results[0]?.path ?? null,
+    durationMs
+  );
+
+  return results;
+}

package/src/search/reranker.ts

@@ -0,0 +1,99 @@
+import { env, AutoTokenizer, AutoModelForSequenceClassification, type PreTrainedTokenizer, type PreTrainedModel } from "@huggingface/transformers";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { rmSync } from "node:fs";
+import { log } from "../utils/log";
+
+// Share the same cache directory as embeddings
+const CACHE_DIR = join(homedir(), ".cache", "local-rag", "models");
+env.cacheDir = CACHE_DIR;
+
+const RERANKER_MODEL_ID = "Xenova/ms-marco-MiniLM-L-6-v2";
+
+let tokenizer: PreTrainedTokenizer | null = null;
+let model: PreTrainedModel | null = null;
+let loadingPromise: Promise<void> | null = null;
+
+async function loadReranker(): Promise<void> {
+  if (tokenizer && model) return;
+  if (loadingPromise) return loadingPromise;
+
+  loadingPromise = (async () => {
+    const start = performance.now();
+    try {
+      tokenizer = await AutoTokenizer.from_pretrained(RERANKER_MODEL_ID, {
+        cache_dir: CACHE_DIR,
+      });
+      model = await AutoModelForSequenceClassification.from_pretrained(RERANKER_MODEL_ID, {
+        dtype: "fp32",
+        cache_dir: CACHE_DIR,
+      });
+      const elapsed = Math.round(performance.now() - start);
+      log.debug(`Reranker loaded in ${elapsed}ms`, "reranker");
+    } catch (err) {
+      // If the cached model is corrupted, delete it and retry once
+      const msg = (err as Error).message || "";
+      if (msg.includes("Protobuf parsing failed") || msg.includes("Load model")) {
+        const modelDir = join(CACHE_DIR, ...RERANKER_MODEL_ID.split("/"));
+        rmSync(modelDir, { recursive: true, force: true });
+        tokenizer = await AutoTokenizer.from_pretrained(RERANKER_MODEL_ID, {
+          cache_dir: CACHE_DIR,
+        });
+        model = await AutoModelForSequenceClassification.from_pretrained(RERANKER_MODEL_ID, {
+          dtype: "fp32",
+          cache_dir: CACHE_DIR,
+        });
+      } else {
+        loadingPromise = null;
+        throw err;
+      }
+    }
+  })();
+
+  return loadingPromise;
+}
+
+/**
+ * Score a list of (query, passage) pairs using a cross-encoder reranker.
+ * Returns relevance scores (higher = more relevant).
+ * Scores are sigmoid-normalized to [0, 1].
+ */
+export async function rerank(
+  query: string,
+  passages: string[],
+): Promise<number[]> {
+  if (passages.length === 0) return [];
+
+  await loadReranker();
+  if (!tokenizer || !model) throw new Error("Reranker failed to load");
+
+  const scores: number[] = [];
+
+  // Process one at a time to avoid OOM on large result sets
+  for (const passage of passages) {
+    const inputs = tokenizer(query, {
+      text_pair: passage,
+      padding: true,
+      truncation: true,
+      max_length: 512,
+    });
+
+    const output = await model(inputs);
+    // Cross-encoder output is a single logit — apply sigmoid
+    const logit = output.logits.data[0] as number;
+    scores.push(sigmoid(logit));
+  }
+
+  return scores;
+}
+
+function sigmoid(x: number): number {
+  return 1 / (1 + Math.exp(-x));
+}
+
+/** Reset the singleton — only for testing */
+export function resetReranker(): void {
+  tokenizer = null;
+  model = null;
+  loadingPromise = null;
+}

package/src/search/usages.ts

@@ -0,0 +1,27 @@
+/**
+ * Utilities for the find_usages feature.
+ *
+ * find_usages works at query time rather than pre-indexing call sites:
+ *   1. FTS search finds chunks containing the symbol name.
+ *   2. Defining files are excluded via the file_exports table.
+ *   3. Within each matching chunk, a word-boundary regex locates the exact line.
+ *   4. Absolute line numbers are computed from the chunk's stored start_line.
+ *
+ * This avoids a full re-index pass and handles all supported file types since
+ * all chunks are in the FTS index regardless of language.
+ */
+
+export function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Sanitize a user query for FTS5 MATCH by quoting each token.
+ * FTS5 treats bare +, -, *, AND, OR, NOT, NEAR, ( ) as operators.
+ * Wrapping each token in double quotes forces literal matching.
+ */
+export function sanitizeFTS(query: string): string {
+  const tokens = query.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return '""';
+  return tokens.map(t => `"${t.replace(/"/g, '""')}"`).join(" ");
+}

package/src/server/index.ts

@@ -0,0 +1,126 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { resolve } from "path";
+import { homedir } from "os";
+import { RagDB } from "../db";
+import { loadConfig } from "../config";
+import { indexDirectory } from "../indexing/indexer";
+import { startWatcher, type Watcher } from "../indexing/watcher";
+import { discoverSessions } from "../conversation/parser";
+import { indexConversation, startConversationTail } from "../conversation/indexer";
+import { registerAllTools } from "../tools";
+import { log } from "../utils/log";
+
+// Read version from package.json at module load time
+const { version } = await import("../../package.json");
+
+// Lazy-init DB per project directory — keep all open to avoid
+// closing a DB that background tasks (auto-index, watcher) still use.
+const dbMap = new Map<string, RagDB>();
+
+function getDB(projectDir: string): RagDB {
+  const resolved = resolve(projectDir);
+  let db = dbMap.get(resolved);
+  if (db) return db;
+  db = new RagDB(resolved);
+  dbMap.set(resolved, db);
+  return db;
+}
+
+export async function startServer() {
+  const server = new McpServer({
+    name: "local-rag",
+    version,
+  });
+
+  // Register all MCP tools
+  registerAllTools(server, getDB);
+
+  // Auto-index on startup + start file watcher
+  const startupDir = process.env.RAG_PROJECT_DIR || process.cwd();
+
+  const isHomeDirTrap = resolve(startupDir) === homedir();
+  if (isHomeDirTrap) {
+    process.stderr.write(
+      `[local-rag] WARNING: project directory is your home folder (${startupDir}).\n` +
+      `[local-rag] Skipping auto-index and file watcher. Set RAG_PROJECT_DIR to your project path.\n` +
+      `[local-rag] Example: "env": { "RAG_PROJECT_DIR": "/path/to/your/project" }\n`
+    );
+  }
+  const startupDb = getDB(startupDir);
+  const startupConfig = await loadConfig(startupDir);
+
+  let watcher: Watcher | null = null;
+  let convWatcher: Watcher | null = null;
+
+  if (!isHomeDirTrap) {
+    // Index in background — don't block server startup
+    indexDirectory(startupDir, startupDb, startupConfig, (msg) => {
+      process.stderr.write(`[local-rag] ${msg}\n`);
+    }).then((result) => {
+      process.stderr.write(
+        `[local-rag] Startup index: ${result.indexed} indexed, ${result.skipped} skipped, ${result.pruned} pruned\n`
+      );
+
+      // Start watching after initial index completes
+      watcher = startWatcher(startupDir, startupDb, startupConfig, (msg) => {
+        process.stderr.write(`[local-rag] ${msg}\n`);
+      });
+    }).catch((err) => {
+      log.warn(`Startup indexing failed: ${err instanceof Error ? err.message : err}`, "server");
+    });
+  }
+
+  // Start conversation tailing — find and tail the current session's JSONL
+  const sessions = discoverSessions(startupDir);
+  if (sessions.length > 0) {
+    // Tail the most recent session (likely the current one)
+    const currentSession = sessions[0];
+    process.stderr.write(`[local-rag] Indexing conversation: ${currentSession.sessionId.slice(0, 8)}...\n`);
+
+    convWatcher = startConversationTail(
+      currentSession.jsonlPath,
+      currentSession.sessionId,
+      startupDb,
+      (msg) => process.stderr.write(`[local-rag] ${msg}\n`)
+    );
+
+    // Also index any older sessions that haven't been indexed yet
+    for (const session of sessions.slice(1)) {
+      const existing = startupDb.getSession(session.sessionId);
+      if (!existing || existing.mtime < session.mtime) {
+        indexConversation(
+          session.jsonlPath,
+          session.sessionId,
+          startupDb
+        ).then((result) => {
+          if (result.turnsIndexed > 0) {
+            process.stderr.write(
+              `[local-rag] Indexed past session ${session.sessionId.slice(0, 8)}...: ${result.turnsIndexed} turns\n`
+            );
+          }
+        }).catch((err) => {
+          log.warn(`Failed to index session ${session.sessionId.slice(0, 8)}: ${err instanceof Error ? err.message : err}`, "conversation");
+        });
+      }
+    }
+  }
+
+  // Graceful shutdown
+  function cleanup() {
+    process.stderr.write("[local-rag] Shutting down...\n");
+    if (watcher) watcher.close();
+    if (convWatcher) convWatcher.close();
+    for (const d of dbMap.values()) d.close();
+    dbMap.clear();
+    process.exit(0);
+  }
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("SIGHUP", cleanup);
+
+  // Start server
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/tools/analytics-tools.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type GetDB, resolveProject } from "./index";
+
+export function registerAnalyticsTools(server: McpServer, getDB: GetDB) {
+  server.tool(
+    "search_analytics",
+    "Show search usage analytics: query counts, zero-result queries, low-relevance queries, top searched terms.",
+    {
+      directory: z
+        .string()
+        .optional()
+        .describe("Project directory. Defaults to RAG_PROJECT_DIR env or cwd"),
+      days: z
+        .number()
+        .optional()
+        .default(30)
+        .describe("Number of days to look back (default: 30)"),
+    },
+    async ({ directory, days }) => {
+      const { db: ragDb } = await resolveProject(directory, getDB);
+      const analytics = ragDb.getAnalytics(days);
+
+      const lines: string[] = [
+        `Search analytics (last ${days} days):`,
+        `  Total queries:    ${analytics.totalQueries}`,
+        `  Avg results:      ${analytics.avgResultCount.toFixed(1)}`,
+        `  Avg top score:    ${analytics.avgTopScore?.toFixed(2) ?? "n/a"}`,
+        `  Zero-result rate: ${analytics.totalQueries > 0 ? ((analytics.zeroResultQueries.reduce((s, q) => s + q.count, 0) / analytics.totalQueries) * 100).toFixed(0) : 0}%`,
+      ];
+
+      if (analytics.topSearchedTerms.length > 0) {
+        lines.push("", "Top searches:");
+        for (const t of analytics.topSearchedTerms) {
+          lines.push(`  - "${t.query}" (${t.count}×)`);
+        }
+      }
+
+      if (analytics.zeroResultQueries.length > 0) {
+        lines.push("", "Zero-result queries (consider indexing these topics):");
+        for (const q of analytics.zeroResultQueries) {
+          lines.push(`  - "${q.query}" (${q.count}×)`);
+        }
+      }
+
+      if (analytics.lowScoreQueries.length > 0) {
+        lines.push("", "Low-relevance queries (top score < 0.3):");
+        for (const q of analytics.lowScoreQueries) {
+          lines.push(`  - "${q.query}" (score: ${q.topScore.toFixed(2)})`);
+        }
+      }
+
+      return {
+        content: [{ type: "text" as const, text: lines.join("\n") }],
+      };
+    }
+  );
+}