@levnikolaevich/hex-line-mcp 1.3.3 → 1.3.5

package/lib/graph-enrich.mjs

@@ -1,226 +0,0 @@
-/**
- * Graph enrichment for hex-line tools.
- *
- * Reads .codegraph/index.db (created by hex-graph-mcp) in readonly mode via a
- * small explicit compatibility contract:
- * - hex_line_contract
- * - hex_line_symbol_annotations
- * - hex_line_call_edges
- *
- * Graceful fallback: if better-sqlite3, contract views, or DB are missing,
- * enrichment is disabled silently for that project.
- */
-
-import { existsSync } from "node:fs";
-import { join, dirname, relative } from "node:path";
-import { createRequire } from "node:module";
-
-const HEX_LINE_CONTRACT_VERSION = 1;
-const _dbs = new Map();
-let _driverUnavailable = false;
-
-/**
- * Get readonly graph DB for a project root.
- * Returns null if DB missing or contract unavailable.
- * @param {string} filePath - any file path inside the project
- * @returns {object|null} better-sqlite3 Database instance or null
- */
-export function getGraphDB(filePath) {
-    if (_driverUnavailable) return null;
-
-    try {
-        const projectRoot = findProjectRoot(filePath);
-        if (!projectRoot) return null;
-
-        const dbPath = join(projectRoot, ".codegraph", "index.db");
-        if (!existsSync(dbPath)) return null;
-        if (_dbs.has(dbPath)) return _dbs.get(dbPath);
-
-        const require = createRequire(import.meta.url);
-        const Database = require("better-sqlite3");
-        const db = new Database(dbPath, { readonly: true });
-        if (!validateHexLineContract(db)) {
-            db.close();
-            return null;
-        }
-        _dbs.set(dbPath, db);
-        return db;
-    } catch {
-        _driverUnavailable = true;
-        return null;
-    }
-}
-
-/**
- * Test helper: close cached DB handles so each test can start clean.
- */
-export function _resetGraphDBCache() {
-    for (const db of _dbs.values()) {
-        try { db.close(); } catch { /* ignore */ }
-    }
-    _dbs.clear();
-    _driverUnavailable = false;
-}
-
-function validateHexLineContract(db) {
-    try {
-        const contract = db.prepare("SELECT contract_version FROM hex_line_contract LIMIT 1").get();
-        if (!contract || contract.contract_version !== HEX_LINE_CONTRACT_VERSION) return false;
-        db.prepare("SELECT node_id, file, line_start, line_end, display_name, kind, callees, callers FROM hex_line_symbol_annotations LIMIT 1").all();
-        db.prepare("SELECT source_id, target_id, source_file, source_line, source_display_name, target_file, target_line, target_display_name FROM hex_line_call_edges LIMIT 1").all();
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Get [N↓ M↑] annotation for a symbol.
- * @param {object} db - better-sqlite3 instance
- * @param {string} file - relative file path
- * @param {string} name - symbol name
- * @returns {string|null} e.g. "[5↓ 3↑]" or null
- */
-export function symbolAnnotation(db, file, name) {
-    try {
-        const node = db.prepare(
-            "SELECT callees, callers FROM hex_line_symbol_annotations WHERE file = ? AND name = ? LIMIT 1"
-        ).get(file, name);
-        if (!node) return null;
-
-        if (node.callees === 0 && node.callers === 0) return null;
-        return `[${node.callees}\u2193 ${node.callers}\u2191]`;
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get all symbol annotations for a file (for read_file Graph: header).
- * @param {object} db
- * @param {string} file - relative file path
- * @returns {Array<{name, kind, callees, callers}>}
- */
-export function fileAnnotations(db, file) {
-    try {
-        const nodes = db.prepare(
-            `SELECT display_name, kind, callees, callers
-             FROM hex_line_symbol_annotations
-             WHERE file = ?
-             ORDER BY line_start`
-        ).all(file);
-
-        return nodes.map((node) => ({
-            name: node.display_name,
-            kind: node.kind,
-            callees: node.callees,
-            callers: node.callers,
-        }));
-    } catch {
-        return [];
-    }
-}
-
-/**
- * Call impact: callers affected by changes in given line range.
- * @param {object} db
- * @param {string} file - relative file path
- * @param {number} startLine
- * @param {number} endLine
- * @returns {Array<{name, file, line}>} affected symbols (max 10)
- */
-export function callImpact(db, file, startLine, endLine) {
-    try {
-        const modified = db.prepare(
-            `SELECT node_id
-             FROM hex_line_symbol_annotations
-             WHERE file = ?
-               AND line_start <= ?
-               AND line_end >= ?`
-        ).all(file, endLine, startLine);
-
-        if (modified.length === 0) return [];
-
-        const affected = [];
-        const seen = new Set();
-
-        for (const node of modified) {
-            const dependents = db.prepare(
-                `SELECT source_display_name AS name, source_file AS file, source_line AS line
-                 FROM hex_line_call_edges
-                 WHERE target_id = ?`
-            ).all(node.node_id);
-
-            for (const dep of dependents) {
-                const key = `${dep.file}:${dep.name}`;
-                if (!seen.has(key) && dep.file !== file) {
-                    seen.add(key);
-                    affected.push({ name: dep.name, file: dep.file, line: dep.line });
-                }
-            }
-        }
-
-        return affected.slice(0, 10);
-    } catch {
-        return [];
-    }
-}
-
-/**
- * Get symbol kind + annotation for a grep match.
- * @param {object} db
- * @param {string} file - relative file path
- * @param {number} line - line number
- * @returns {string|null} e.g. "[fn 5↓ 3↑]" or null
- */
-export function matchAnnotation(db, file, line) {
-    try {
-        const node = db.prepare(
-            `SELECT display_name, kind, callees, callers
-             FROM hex_line_symbol_annotations
-             WHERE file = ? AND line_start <= ? AND line_end >= ?
-             ORDER BY line_start DESC
-             LIMIT 1`
-        ).get(file, line, line);
-        if (!node) return null;
-
-        const kindShort = { function: "fn", class: "cls", method: "mtd", variable: "var" }[node.kind] || node.kind;
-        if (node.callees === 0 && node.callers === 0) return `[${kindShort}]`;
-        return `[${kindShort} ${node.callees}\u2193 ${node.callers}\u2191]`;
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get relative path from project root (matching DB paths).
- * @param {string} filePath - absolute file path
- * @returns {string|null} relative path with forward slashes, or null
- */
-export function getRelativePath(filePath) {
-    const root = findProjectRoot(filePath);
-    if (!root) return null;
-    return relative(root, filePath).replace(/\\/g, "/");
-}
-
-// --- Helpers ---
-
-function findProjectRoot(filePath) {
-    // First pass: look for .codegraph/index.db (strongest signal)
-    let dir = dirname(filePath);
-    for (let i = 0; i < 10; i++) {
-        if (existsSync(join(dir, ".codegraph", "index.db"))) return dir;
-        const parent = dirname(dir);
-        if (parent === dir) break;
-        dir = parent;
-    }
-    // Second pass: fallback to .git
-    dir = dirname(filePath);
-    for (let i = 0; i < 10; i++) {
-        if (existsSync(join(dir, ".git"))) return dir;
-        const parent = dirname(dir);
-        if (parent === dir) break;
-        dir = parent;
-    }
-    return null;
-}

package/lib/hash.mjs

@@ -1 +0,0 @@
-export * from "@levnikolaevich/hex-common/text-protocol/hash";

package/lib/info.mjs

@@ -1,91 +0,0 @@
-/**
- * File metadata without reading content.
- *
- * Returns: size, line count, modification time, type, binary detection.
- */
-
-import { statSync, openSync, readSync, closeSync } from "node:fs";
-import { resolve, isAbsolute, extname, basename } from "node:path";
-import { normalizePath } from "./security.mjs";
-import { formatSize, relativeTime, countFileLines } from "./format.mjs";
-
-const MAX_LINE_COUNT_SIZE = 10 * 1024 * 1024; // 10 MB
-
-const EXT_NAMES = {
-    ".ts": "TypeScript source", ".tsx": "TypeScript JSX source",
-    ".js": "JavaScript source", ".jsx": "JavaScript JSX source",
-    ".mjs": "JavaScript ESM source", ".cjs": "JavaScript CJS source",
-    ".py": "Python source", ".rb": "Ruby source", ".rs": "Rust source",
-    ".go": "Go source", ".java": "Java source", ".kt": "Kotlin source",
-    ".swift": "Swift source", ".c": "C source", ".cpp": "C++ source",
-    ".h": "C/C++ header", ".cs": "C# source", ".php": "PHP source",
-    ".sh": "Shell script", ".bash": "Bash script", ".zsh": "Zsh script",
-    ".json": "JSON data", ".yaml": "YAML data", ".yml": "YAML data",
-    ".toml": "TOML config", ".xml": "XML document", ".html": "HTML document",
-    ".css": "CSS stylesheet", ".scss": "SCSS stylesheet", ".less": "LESS stylesheet",
-    ".md": "Markdown document", ".txt": "Plain text", ".csv": "CSV data",
-    ".sql": "SQL script", ".graphql": "GraphQL schema",
-    ".png": "PNG image", ".jpg": "JPEG image", ".jpeg": "JPEG image",
-    ".gif": "GIF image", ".svg": "SVG image", ".ico": "Icon file",
-    ".pdf": "PDF document", ".zip": "ZIP archive", ".tar": "TAR archive",
-    ".gz": "Gzip archive", ".wasm": "WebAssembly binary",
-    ".lock": "Lock file", ".env": "Environment config",
-    ".dockerfile": "Dockerfile", ".vue": "Vue component", ".svelte": "Svelte component",
-};
-
-
-function detectBinary(filePath, size) {
-    if (size === 0) return false;
-    const fd = openSync(filePath, "r");
-    const probe = Buffer.alloc(Math.min(size, 8192));
-    const bytesRead = readSync(fd, probe, 0, probe.length, 0);
-    closeSync(fd);
-    for (let i = 0; i < bytesRead; i++) {
-        if (probe[i] === 0) return true;
-    }
-    return false;
-}
-
-/**
- * Get file metadata without reading full content.
- * @param {string} filePath
- * @returns {string} Formatted metadata
- */
-export function fileInfo(filePath) {
-    if (!filePath) throw new Error("Empty file path");
-    const normalized = normalizePath(filePath);
-    const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
-
-    const stat = statSync(abs);
-    if (!stat.isFile()) throw new Error(`Not a regular file: ${abs}`);
-
-    const size = stat.size;
-    const mtime = stat.mtime;
-    const ext = extname(abs).toLowerCase();
-    const name = basename(abs);
-
-    // File type
-    let typeName = EXT_NAMES[ext] || (ext ? `${ext.slice(1).toUpperCase()} file` : "Unknown type");
-    if (name === "Dockerfile") typeName = "Dockerfile";
-    if (name === "Makefile") typeName = "Makefile";
-
-    // Binary detection
-    const isBinary = size > 0 ? detectBinary(abs, size) : false;
-
-    // Line count (only for non-binary, <=10MB)
-    const lineCount = !isBinary && size > 0 ? countFileLines(abs, size, MAX_LINE_COUNT_SIZE) : null;
-
-    // Format output
-    const sizeStr = lineCount !== null
-        ? `Size: ${formatSize(size)} (${lineCount} lines)`
-        : `Size: ${formatSize(size)}`;
-    const timeStr = `Modified: ${mtime.toISOString().replace("T", " ").slice(0, 19)} (${relativeTime(mtime)})`;
-
-    return [
-        `File: ${normalized}`,
-        sizeStr,
-        timeStr,
-        `Type: ${typeName}`,
-        `Binary: ${isBinary ? "yes" : "no"}`,
-    ].join("\n");
-}

package/lib/normalize.mjs

@@ -1 +0,0 @@
-export * from "@levnikolaevich/hex-common/output/normalize";

package/lib/outline.mjs

@@ -1,145 +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 { extname } from "node:path";
-import { getParser, getLanguage } from "@levnikolaevich/hex-common/parser/tree-sitter";
-import { grammarForExtension, supportedExtensions } from "@levnikolaevich/hex-common/parser/languages";
-import { readUtf8Normalized } from "@levnikolaevich/hex-common/text/file-text";
-import { validatePath, normalizePath } from "./security.mjs";
-import { getGraphDB, symbolAnnotation, getRelativePath } from "./graph-enrich.mjs";
-
-const LANG_CONFIGS = {
-    ".js":   { outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".mjs":  { outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".jsx":  { outline: ["function_declaration", "class_declaration", "variable_declaration", "export_statement", "lexical_declaration"], skip: ["import_statement"], recurse: ["class_body"] },
-    ".ts":   { 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":  { 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":   { outline: ["function_definition", "class_definition", "decorated_definition"], skip: ["import_statement", "import_from_statement"], recurse: ["class_body", "block"] },
-    ".go":   { outline: ["function_declaration", "method_declaration", "type_declaration"], skip: ["import_declaration"], recurse: [] },
-    ".rs":   { outline: ["function_item", "struct_item", "enum_item", "impl_item", "trait_item", "const_item", "static_item"], skip: ["use_declaration"], recurse: ["impl_item"] },
-    ".java": { outline: ["class_declaration", "interface_declaration", "method_declaration", "enum_declaration"], skip: ["import_declaration"], recurse: ["class_body"] },
-    ".c":    { outline: ["function_definition", "struct_specifier", "enum_specifier", "type_definition"], skip: ["preproc_include"], recurse: [] },
-    ".h":    { outline: ["function_definition", "struct_specifier", "enum_specifier", "type_definition"], skip: ["preproc_include"], recurse: [] },
-    ".cpp":  { outline: ["function_definition", "class_specifier", "struct_specifier", "namespace_definition"], skip: ["preproc_include"], recurse: ["class_specifier"] },
-    ".cs":   { outline: ["class_declaration", "interface_declaration", "method_declaration", "namespace_declaration"], skip: ["using_directive"], recurse: ["class_body"] },
-    ".rb":   { outline: ["method", "class", "module"], skip: ["require", "require_relative"], recurse: ["class", "module"] },
-    ".php":  { outline: ["function_definition", "class_declaration", "method_declaration"], skip: ["namespace_use_declaration"], recurse: ["class_body"] },
-    ".kt":   { outline: ["function_declaration", "class_declaration", "object_declaration"], skip: ["import_header"], recurse: ["class_body"] },
-    ".swift": { outline: ["function_declaration", "class_declaration", "struct_declaration", "protocol_declaration"], skip: ["import_declaration"], recurse: ["class_body"] },
-    ".sh":   { outline: ["function_definition"], skip: [], recurse: [] },
-    ".bash": { outline: ["function_definition"], skip: [], recurse: [] },
-};
-
-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] || "";
-                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,
-                });
-
-                for (let j = 0; j < child.childCount; j++) {
-                    const sub = child.child(j);
-                    if (recurseTypes.has(sub.type)) walk(sub, depth + 1);
-                }
-            }
-        }
-    }
-
-    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 };
-}
-
-export async function outlineFromContent(content, ext) {
-    const config = LANG_CONFIGS[ext];
-    const grammar = grammarForExtension(ext);
-    if (!config || !grammar) return null;
-
-    const sourceLines = content.split("\n");
-
-    let lang;
-    try {
-        lang = await getLanguage(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);
-}
-
-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");
-}
-
-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: ${supportedExtensions().join(", ")}`;
-    }
-
-    const content = readUtf8Normalized(real);
-    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,138 +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 "@levnikolaevich/hex-common/text-protocol/hash";
-import { validatePath, normalizePath } from "./security.mjs";
-import { getGraphDB, fileAnnotations, getRelativePath } from "./graph-enrich.mjs";
-import { relativeTime, listDirectory, readText, MAX_OUTPUT_CHARS } from "./format.mjs";
-import { rememberSnapshot } from "./revisions.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 snapshot = rememberSnapshot(real, readText(real), { mtimeMs: stat.mtimeMs, size: stat.size });
-    const lines = snapshot.lines;
-    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}\nrevision: ${snapshot.revision}\nfile: ${snapshot.fileChecksum}\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;
-}