@levnikolaevich/hex-line-mcp 1.3.2 → 1.3.4

package/lib/outline.mjs

@@ -1,201 +0,0 @@
-/**
- * AST-based file outline via tree-sitter WASM.
- *
- * Returns structural overview: functions, classes, interfaces with line ranges.
- * 10-20 lines instead of 500 → 95% token reduction.
- * Output maps directly to read_file ranges.
- */
-
-import { readFileSync } from "node:fs";
-import { resolve, extname } from "node:path";
-import { validatePath, normalizePath } from "./security.mjs";
-import { getGraphDB, symbolAnnotation, getRelativePath } from "./graph-enrich.mjs";
-
-// Language configs: extension → { grammar, outline, skip, recurse }
-const LANG_CONFIGS = {
-    ".js":   { grammar: "javascript", outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".mjs":  { grammar: "javascript", outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".jsx":  { grammar: "javascript", outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".ts":   { grammar: "typescript", outline: ["function_declaration", "class_declaration", "interface_declaration", "type_alias_declaration", "enum_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".tsx":  { grammar: "tsx", outline: ["function_declaration", "class_declaration", "interface_declaration", "type_alias_declaration", "enum_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".py":   { grammar: "python", outline: ["function_definition", "class_definition", "decorated_definition"], skip: ["import_statement", "import_from_statement"], recurse: ["class_body", "block"] },
-    ".go":   { grammar: "go", outline: ["function_declaration", "method_declaration", "type_declaration"], skip: ["import_declaration"], recurse: [] },
-    ".rs":   { grammar: "rust", outline: ["function_item", "struct_item", "enum_item", "impl_item", "trait_item", "const_item", "static_item"], skip: ["use_declaration"], recurse: ["impl_item"] },
-    ".java": { grammar: "java", outline: ["class_declaration", "interface_declaration", "method_declaration", "enum_declaration"], skip: ["import_declaration"], recurse: ["class_body"] },
-    ".c":    { grammar: "c", outline: ["function_definition", "struct_specifier", "enum_specifier", "type_definition"], skip: ["preproc_include"], recurse: [] },
-    ".h":    { grammar: "c", outline: ["function_definition", "struct_specifier", "enum_specifier", "type_definition"], skip: ["preproc_include"], recurse: [] },
-    ".cpp":  { grammar: "cpp", outline: ["function_definition", "class_specifier", "struct_specifier", "namespace_definition"], skip: ["preproc_include"], recurse: ["class_specifier"] },
-    ".cs":   { grammar: "c_sharp", outline: ["class_declaration", "interface_declaration", "method_declaration", "namespace_declaration"], skip: ["using_directive"], recurse: ["class_body"] },
-    ".rb":   { grammar: "ruby", outline: ["method", "class", "module"], skip: ["require", "require_relative"], recurse: ["class", "module"] },
-    ".php":  { grammar: "php", outline: ["function_definition", "class_declaration", "method_declaration"], skip: ["namespace_use_declaration"], recurse: ["class_body"] },
-    ".kt":   { grammar: "kotlin", outline: ["function_declaration", "class_declaration", "object_declaration"], skip: ["import_header"], recurse: ["class_body"] },
-    ".swift": { grammar: "swift", outline: ["function_declaration", "class_declaration", "struct_declaration", "protocol_declaration"], skip: ["import_declaration"], recurse: ["class_body"] },
-    ".sh":   { grammar: "bash", outline: ["function_definition"], skip: [], recurse: [] },
-    ".bash": { grammar: "bash", outline: ["function_definition"], skip: [], recurse: [] },
-};
-
-// Parser cache (init once)
-let _parser = null;
-const _langCache = new Map();
-
-async function getParser() {
-    if (_parser) return _parser;
-    try {
-        const { Parser } = await import("web-tree-sitter");
-        await Parser.init();
-        _parser = new Parser();
-        return _parser;
-    } catch (e) {
-        throw new Error(`tree-sitter init failed: ${e.message}. Run: cd mcp/hex-line-mcp && npm install`);
-    }
-}
-
-async function getLanguage(grammar) {
-    if (_langCache.has(grammar)) return _langCache.get(grammar);
-    await getParser(); // ensure init
-    try {
-        const { Language } = await import("web-tree-sitter");
-        const { createRequire } = await import("node:module");
-        const require = createRequire(import.meta.url);
-        // Absolute path for Windows compatibility (Gemini finding #3)
-        const wasmPath = resolve(require.resolve("tree-sitter-wasms/package.json"), "..", "out", `tree-sitter-${grammar}.wasm`);
-        const lang = await Language.load(wasmPath);
-        _langCache.set(grammar, lang);
-        return lang;
-    } catch (e) {
-        throw new Error(`Language "${grammar}" not available: ${e.message}`);
-    }
-}
-
-/**
- * Extract structural outline entries from AST.
- */
-function extractOutline(rootNode, config, sourceLines) {
-    const entries = [];
-    const skipTypes = new Set(config.skip);
-    const outlineTypes = new Set(config.outline);
-    const recurseTypes = new Set(config.recurse);
-
-    function walk(node, depth) {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            const type = child.type;
-            const startLine = child.startPosition.row + 1;
-            const endLine = child.endPosition.row + 1;
-
-            if (skipTypes.has(type)) continue;
-
-            if (outlineTypes.has(type)) {
-                const firstLine = sourceLines[startLine - 1] || "";
-                // Extract symbol name for graph annotation
-                const nameMatch = firstLine.match(/(?:function|class|interface|type|enum|struct|def|fn|pub\s+fn)\s+(\w+)|(?:const|let|var|export\s+(?:const|let|var|function|class))\s+(\w+)/);
-                const name = nameMatch ? (nameMatch[1] || nameMatch[2]) : null;
-
-                entries.push({
-                    start: startLine,
-                    end: endLine,
-                    depth,
-                    text: firstLine.trim().slice(0, 120),
-                    name,
-                });
-
-                // Recurse into class/struct bodies
-                for (let j = 0; j < child.childCount; j++) {
-                    const sub = child.child(j);
-                    if (recurseTypes.has(sub.type)) {
-                        walk(sub, depth + 1);
-                    }
-                }
-            }
-        }
-    }
-
-    // Collect skipped ranges for summary
-    const skippedRanges = [];
-    for (let i = 0; i < rootNode.childCount; i++) {
-        const child = rootNode.child(i);
-        if (skipTypes.has(child.type)) {
-            skippedRanges.push({
-                start: child.startPosition.row + 1,
-                end: child.endPosition.row + 1,
-            });
-        }
-    }
-
-    walk(rootNode, 0);
-    return { entries, skippedRanges };
-}
-
-/**
- * Parse content string into outline entries.
- * Reusable core — no file I/O, no validatePath.
- *
- * @param {string} content  Source text (LF-normalized)
- * @param {string} ext      Lowercase extension including dot (e.g. ".mjs")
- * @returns {Promise<{entries: Array, skippedRanges: Array} | null>}  null if unsupported ext
- */
-export async function outlineFromContent(content, ext) {
-    const config = LANG_CONFIGS[ext];
-    if (!config) return null;
-
-    const sourceLines = content.split("\n");
-
-    let lang;
-    try {
-        lang = await getLanguage(config.grammar);
-    } catch (e) {
-        throw new Error(`Outline error: ${e.message}`);
-    }
-
-    const parser = await getParser();
-    parser.setLanguage(lang);
-    const tree = parser.parse(content);
-    return extractOutline(tree.rootNode, config, sourceLines);
-}
-
-/**
- * Format outline entries into display string.
- */
-function formatOutline(entries, skippedRanges, sourceLineCount, db, relFile) {
-    const lines = [];
-
-    if (skippedRanges.length > 0) {
-        const first = skippedRanges[0].start;
-        const last = skippedRanges[skippedRanges.length - 1].end;
-        const count = skippedRanges.reduce((sum, r) => sum + (r.end - r.start + 1), 0);
-        lines.push(`${first}-${last}: (${count} imports/declarations)`);
-    }
-
-    for (const e of entries) {
-        const indent = "  ".repeat(e.depth);
-        const anno = db ? symbolAnnotation(db, relFile, e.name) : null;
-        const suffix = anno ? `  ${anno}` : "";
-        lines.push(`${indent}${e.start}-${e.end}: ${e.text}${suffix}`);
-    }
-
-    lines.push("");
-    lines.push(`(${entries.length} symbols, ${sourceLineCount} source lines)`);
-    return lines.join("\n");
-}
-
-/**
- * Generate file outline.
- *
- * @param {string} filePath
- * @returns {Promise<string>} formatted outline
- */
-export async function fileOutline(filePath) {
-    filePath = normalizePath(filePath);
-    const real = validatePath(filePath);
-    const ext = extname(real).toLowerCase();
-
-    if (!LANG_CONFIGS[ext]) {
-        return `Outline unavailable for ${ext} files. Use read_file directly for non-code files (markdown, config, text). Supported code extensions: ${Object.keys(LANG_CONFIGS).join(", ")}`;
-    }
-
-    const content = readFileSync(real, "utf-8").replace(/\r\n/g, "\n");
-    const result = await outlineFromContent(content, ext);
-    const db = getGraphDB(real);
-    const relFile = db ? getRelativePath(real) : null;
-    return `File: ${filePath}\n\n${formatOutline(result.entries, result.skippedRanges, content.split("\n").length, db, relFile)}`;
-}

package/lib/read.mjs

@@ -1,136 +0,0 @@
-/**
- * File read with FNV-1a hash annotations and range checksums.
- *
- * Output format: {tag}.{lineNum}\t{content}
- * Appends: checksum: {start}-{end}:{8hex}
- */
-
-import { statSync } from "node:fs";
-import { fnv1a, lineTag, rangeChecksum } from "./hash.mjs";
-import { validatePath, normalizePath } from "./security.mjs";
-import { getGraphDB, fileAnnotations, getRelativePath } from "./graph-enrich.mjs";
-import { relativeTime, listDirectory, readText, MAX_OUTPUT_CHARS } from "./format.mjs";
-
-const DEFAULT_LIMIT = 2000;
-
-/**
- * Read a file with hash-annotated lines.
- *
- * @param {string} filePath
- * @param {object} opts - { offset, limit, plain, ranges }
- * @returns {string} formatted output
- */
-export function readFile(filePath, opts = {}) {
-    filePath = normalizePath(filePath);
-    const real = validatePath(filePath);
-    const stat = statSync(real);
-
-    // Directory listing fallback
-    if (stat.isDirectory()) {
-        const { text } = listDirectory(real, { metadata: true });
-        return `Directory: ${filePath}\n\n\`\`\`\n${text}\n\`\`\``;
-    }
-
-    const content = readText(real);
-    const lines = content.split("\n");
-    const total = lines.length;
-
-    // Determine ranges to read
-    let ranges;
-    if (opts.ranges && opts.ranges.length > 0) {
-        ranges = opts.ranges.map((r) => ({
-            start: Math.max(1, r.start || 1),
-            end: Math.min(total, r.end || total),
-        }));
-    } else {
-        const startLine = Math.max(1, opts.offset || 1);
-        const maxLines = (opts.limit && opts.limit > 0) ? opts.limit : DEFAULT_LIMIT;
-        ranges = [{ start: startLine, end: Math.min(total, startLine - 1 + maxLines) }];
-    }
-
-    const parts = [];
-
-    let cappedAtLine = 0;
-
-    for (const range of ranges) {
-        const selected = lines.slice(range.start - 1, range.end);
-        const lineHashes = [];
-        const formatted = [];
-        let charCount = 0;
-
-        for (let i = 0; i < selected.length; i++) {
-            const line = selected[i];
-            const num = range.start + i;
-            const hash32 = fnv1a(line);
-            const entry = opts.plain
-                ? `${num}|${line}`
-                : `${lineTag(hash32)}.${num}\t${line}`;
-
-            if (charCount + entry.length > MAX_OUTPUT_CHARS && formatted.length > 0) {
-                cappedAtLine = num;
-                break;
-            }
-            lineHashes.push(hash32);
-            formatted.push(entry);
-            charCount += entry.length + 1;
-        }
-
-        // Update range end to actual lines shown
-        const actualEnd = formatted.length > 0
-            ? range.start + formatted.length - 1
-            : range.start;
-        range.end = actualEnd;
-
-        parts.push(formatted.join("\n"));
-
-        // Range checksum (only for lines actually shown)
-        const cs = rangeChecksum(lineHashes, range.start, actualEnd);
-        parts.push(`\nchecksum: ${cs}`);
-
-        if (cappedAtLine) break;
-    }
-
-    // Header
-    const sizeKB = (stat.size / 1024).toFixed(1);
-    const mtime = stat.mtime;
-    const ago = relativeTime(mtime);
-    let header = `File: ${filePath} (${total} lines, ${sizeKB}KB, ${ago})`;
-    if (ranges.length === 1) {
-        const r = ranges[0];
-        if (r.start > 1 || r.end < total) {
-            header += ` [showing ${r.start}-${r.end}]`;
-        }
-        if (r.end < total) {
-            header += ` (${total - r.end} more below)`;
-        }
-    }
-
-    // Graph enrichment (optional — silent if no DB)
-    const db = getGraphDB(real);
-    const relFile = db ? getRelativePath(real) : null;
-    let graphLine = "";
-    if (db && relFile) {
-        const annos = fileAnnotations(db, relFile);
-        if (annos.length > 0) {
-            const items = annos.map(a => {
-                const counts = (a.callees || a.callers) ? ` ${a.callees}\u2193 ${a.callers}\u2191` : "";
-                return `${a.name} [${a.kind}${counts}]`;
-            });
-            graphLine = `\nGraph: ${items.join(" | ")}`;
-        }
-    }
-
-    let result = `${header}${graphLine}\n\n\`\`\`\n${parts.join("\n")}\n\`\`\``;
-
-    // Auto-hint for large files read from start without offset
-    if (total > 200 && (!opts.offset || opts.offset <= 1) && !cappedAtLine) {
-        result += `\n\n\u26A1 Tip: This file has ${total} lines. Use outline first, then read_file with offset/limit for 75% fewer tokens.`;
-    }
-
-    // Character cap notice
-    if (cappedAtLine) {
-        result += `\n\nOUTPUT_CAPPED at line ${cappedAtLine} (${MAX_OUTPUT_CHARS} char limit). Use offset=${cappedAtLine} to continue reading.`;
-    }
-
-    return result;
-}

package/lib/search.mjs

@@ -1,269 +0,0 @@
-/**
- * File search via ripgrep with hash-annotated results.
- * Uses spawn with arg arrays (no shell string interpolation).
- *
- * Output modes:
- *   content (default) — hash-annotated lines with per-group checksums (uses rg --json)
- *   files — file paths only (rg -l)
- *   count — match counts per file (rg -c)
- */
-
-import { spawn } from "node:child_process";
-import { resolve } from "node:path";
-import { fnv1a, lineTag, rangeChecksum } from "./hash.mjs";
-import { getGraphDB, matchAnnotation, getRelativePath } from "./graph-enrich.mjs";
-import { normalizePath } from "./security.mjs";
-
-const DEFAULT_LIMIT = 100;
-const MAX_OUTPUT = 10 * 1024 * 1024; // 10 MB
-const TIMEOUT = 30000; // 30s
-
-
-
-/**
- * Spawn ripgrep and collect stdout.
- * Returns { stdout, code, stderr, killed }.
- */
-function spawnRg(args) {
-    return new Promise((resolve_, reject) => {
-        let stdout = "";
-        let totalBytes = 0;
-        let killed = false;
-        let stderrBuf = "";
-
-        const child = spawn("rg", args, { timeout: TIMEOUT });
-
-        child.stdout.on("data", (chunk) => {
-            totalBytes += chunk.length;
-            if (totalBytes > MAX_OUTPUT) {
-                killed = true;
-                child.kill();
-                return;
-            }
-            stdout += chunk.toString("utf-8");
-        });
-
-        child.stderr.on("data", (chunk) => { stderrBuf += chunk.toString("utf-8"); });
-
-        child.on("error", (err) => {
-            if (err.code === "ENOENT") {
-                reject(new Error("ripgrep (rg) not found. Install: https://github.com/BurntSushi/ripgrep#installation"));
-            } else {
-                reject(new Error(`rg spawn error: ${err.message}`));
-            }
-        });
-
-        child.on("close", (code) => {
-            resolve_({ stdout, code, stderr: stderrBuf, killed });
-        });
-    });
-}
-
-/**
- * Search files using ripgrep.
- *
- * @param {string} pattern - regex or literal pattern
- * @param {object} opts
- * @returns {Promise<string>} formatted results
- */
-export function grepSearch(pattern, opts = {}) {
-    const normPath = normalizePath(opts.path || "");
-    const target = normPath ? resolve(normPath) : process.cwd();
-    const output = opts.output || "content";
-    const plain = !!opts.plain;
-    const totalLimit = (opts.totalLimit && opts.totalLimit > 0) ? opts.totalLimit : 0;
-
-    // Branch by output mode
-    if (output === "files") return filesMode(pattern, target, opts);
-    if (output === "count") return countMode(pattern, target, opts);
-    return contentMode(pattern, target, opts, plain, totalLimit);
-}
-
-/**
- * files mode: rg -l — just file paths.
- */
-async function filesMode(pattern, target, opts) {
-    // -l + shared flags (without -n/heading/-m since -l ignores them)
-    const realArgs = ["-l"];
-    if (opts.caseInsensitive) realArgs.push("-i");
-    else if (opts.smartCase) realArgs.push("-S");
-    if (opts.literal) realArgs.push("-F");
-    if (opts.multiline) realArgs.push("-U", "--multiline-dotall");
-    if (opts.glob) realArgs.push("--glob", opts.glob);
-    if (opts.type) realArgs.push("--type", opts.type);
-    realArgs.push("--", pattern, target);
-
-    const { stdout, code, stderr, killed } = await spawnRg(realArgs);
-    if (killed) return "GREP_OUTPUT_TRUNCATED: exceeded 10MB. Use specific glob/path.";
-    if (code === 1) return "No matches found.";
-    if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} — ${stderr.trim() || "unknown error"}`);
-
-    const lines = stdout.trimEnd().split("\n").filter(Boolean);
-    const normalized = lines.map(l => l.replace(/\\/g, "/"));
-    return `\`\`\`\n${normalized.join("\n")}\n\`\`\``;
-}
-
-/**
- * count mode: rg -c — match counts per file.
- */
-async function countMode(pattern, target, opts) {
-    const realArgs = ["-c"];
-    if (opts.caseInsensitive) realArgs.push("-i");
-    else if (opts.smartCase) realArgs.push("-S");
-    if (opts.literal) realArgs.push("-F");
-    if (opts.multiline) realArgs.push("-U", "--multiline-dotall");
-    if (opts.glob) realArgs.push("--glob", opts.glob);
-    if (opts.type) realArgs.push("--type", opts.type);
-    realArgs.push("--", pattern, target);
-
-    const { stdout, code, stderr, killed } = await spawnRg(realArgs);
-    if (killed) return "GREP_OUTPUT_TRUNCATED: exceeded 10MB. Use specific glob/path.";
-    if (code === 1) return "No matches found.";
-    if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} — ${stderr.trim() || "unknown error"}`);
-
-    const lines = stdout.trimEnd().split("\n").filter(Boolean);
-    const normalized = lines.map(l => l.replace(/\\/g, "/"));
-    return `\`\`\`\n${normalized.join("\n")}\n\`\`\``;
-}
-
-/**
- * content mode: rg --json — hash-annotated lines with per-group checksums.
- */
-async function contentMode(pattern, target, opts, plain, totalLimit) {
-    const realArgs = ["--json"];
-    if (opts.caseInsensitive) realArgs.push("-i");
-    else if (opts.smartCase) realArgs.push("-S");
-    if (opts.literal) realArgs.push("-F");
-    if (opts.multiline) realArgs.push("-U", "--multiline-dotall");
-    if (opts.glob) realArgs.push("--glob", opts.glob);
-    if (opts.type) realArgs.push("--type", opts.type);
-    if (opts.context && opts.context > 0) realArgs.push("-C", String(opts.context));
-    if (opts.contextBefore && opts.contextBefore > 0) realArgs.push("-B", String(opts.contextBefore));
-    if (opts.contextAfter && opts.contextAfter > 0) realArgs.push("-A", String(opts.contextAfter));
-
-    const limit = (opts.limit && opts.limit > 0) ? opts.limit : DEFAULT_LIMIT;
-    realArgs.push("-m", String(limit));
-    realArgs.push("--", pattern, target);
-
-    const { stdout, code, stderr, killed } = await spawnRg(realArgs);
-    if (killed) return "GREP_OUTPUT_TRUNCATED: exceeded 10MB. Use specific glob/path.";
-    if (code === 1) return "No matches found.";
-    if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} — ${stderr.trim() || "unknown error"}`);
-
-    // Parse NDJSON output
-    const jsonLines = stdout.trimEnd().split("\n").filter(Boolean);
-    const formatted = [];
-    const db = getGraphDB(target);
-    const relCache = new Map();
-
-    // Track current group for checksums
-    let groupFile = null;
-    let groupLines = [];   // { lineNum, hash32 }
-    let matchCount = 0;
-
-    function flushGroup() {
-        if (groupLines.length === 0) return;
-        const sorted = [...groupLines].sort((a, b) => a.lineNum - b.lineNum);
-        const start = sorted[0].lineNum;
-        const end = sorted[sorted.length - 1].lineNum;
-        const hashes = sorted.map(l => l.hash32);
-        const cs = rangeChecksum(hashes, start, end);
-        formatted.push(`checksum: ${cs}`);
-        groupLines = [];
-    }
-
-    for (const jl of jsonLines) {
-        let msg;
-        try { msg = JSON.parse(jl); } catch { continue; }
-
-        if (msg.type === "begin" || msg.type === "end" || msg.type === "summary") {
-            if (msg.type === "end") {
-                flushGroup();
-                groupFile = null;
-            }
-            if (msg.type === "begin") {
-                // Separator between file groups
-                if (formatted.length > 0 && formatted[formatted.length - 1] !== "") {
-                    formatted.push("");
-                }
-            }
-            continue;
-        }
-
-        if (msg.type !== "match" && msg.type !== "context") continue;
-
-        const data = msg.data;
-        const filePath = (data.path?.text || "").replace(/\\/g, "/");
-        const lineNum = data.line_number;
-        if (!lineNum) continue;
-
-        // Get line content (handle text vs bytes)
-        let content = data.lines?.text;
-        if (content === undefined && data.lines?.bytes) {
-            content = Buffer.from(data.lines.bytes, "base64").toString("utf-8");
-        }
-        if (content === undefined) continue;
-
-        // Trim trailing newline from rg JSON output
-        content = content.replace(/\n$/, "");
-
-        // Handle multiline: split into individual lines
-        const subLines = content.split("\n");
-
-        // Track group boundaries
-        if (filePath !== groupFile) {
-            flushGroup();
-            groupFile = filePath;
-        }
-
-        for (let i = 0; i < subLines.length; i++) {
-            const ln = lineNum + i;
-            const lineContent = subLines[i];
-            const hash32 = fnv1a(lineContent);
-            const tag = lineTag(hash32);
-
-            // Flush on line gap (disjoint match clusters get separate checksums)
-            if (groupLines.length > 0) {
-                const lastLn = groupLines[groupLines.length - 1].lineNum;
-                if (ln > lastLn + 1) flushGroup();
-            }
-            groupLines.push({ lineNum: ln, hash32 });
-
-            const isMatch = msg.type === "match";
-            if (plain) {
-                formatted.push(`${filePath}:${ln}:${lineContent}`);
-            } else {
-                let anno = "";
-                if (db && isMatch) {
-                    let rel = relCache.get(filePath);
-                    if (rel === undefined) {
-                        rel = getRelativePath(resolve(filePath)) || "";
-                        relCache.set(filePath, rel);
-                    }
-                    if (rel) {
-                        const a = matchAnnotation(db, rel, ln);
-                        if (a) anno = `  ${a}`;
-                    }
-                }
-                const prefix = isMatch ? ">>" : "  ";
-                formatted.push(`${filePath}:${prefix}${tag}.${ln}\t${lineContent}${anno}`);
-            }
-
-        }
-
-        // Count matches per rg event, not per subLine
-        if (msg.type === "match") {
-            matchCount++;
-            if (totalLimit > 0 && matchCount >= totalLimit) {
-                flushGroup();
-                formatted.push(`--- total_limit reached (${totalLimit}) ---`);
-                return `\`\`\`\n${formatted.join("\n")}\n\`\`\``;
-            }
-        }
-    }
-
-    // Flush last group
-    flushGroup();
-
-    return `\`\`\`\n${formatted.join("\n")}\n\`\`\``;
-}