@levnikolaevich/hex-line-mcp 1.3.3 → 1.3.4

package/lib/revisions.mjs

@@ -1,238 +0,0 @@
-/**
- * Revision journal for hex-line-mcp.
- *
- * Keeps short-lived file snapshots in memory so read/edit/verify can reuse
- * line hashes, file checksums, and changed ranges without re-reading the file
- * on every same-file operation.
- */
-
-import { statSync } from "node:fs";
-import { diffLines } from "diff";
-import { fnv1a, lineTag, rangeChecksum } from "@levnikolaevich/hex-common/text-protocol/hash";
-import { readText } from "./format.mjs";
-
-const MAX_FILES = 200;
-const MAX_REVISIONS_PER_FILE = 5;
-const TTL_MS = 5 * 60 * 1000;
-
-const latestByFile = new Map();
-const revisionsById = new Map();
-const fileRevisionIds = new Map();
-let revisionSeq = 0;
-
-function touchFile(filePath) {
-    const latest = latestByFile.get(filePath);
-    if (!latest) return;
-    latestByFile.delete(filePath);
-    latestByFile.set(filePath, latest);
-}
-
-function pruneExpired(now = Date.now()) {
-    for (const [revision, snapshot] of revisionsById) {
-        if (now - snapshot.createdAt <= TTL_MS) continue;
-        revisionsById.delete(revision);
-        const ids = fileRevisionIds.get(snapshot.path);
-        if (!ids) continue;
-        const next = ids.filter(id => id !== revision);
-        if (next.length > 0) fileRevisionIds.set(snapshot.path, next);
-        else fileRevisionIds.delete(snapshot.path);
-        const latest = latestByFile.get(snapshot.path);
-        if (latest?.revision === revision) latestByFile.delete(snapshot.path);
-    }
-    while (latestByFile.size > MAX_FILES) {
-        const oldestPath = latestByFile.keys().next().value;
-        const ids = fileRevisionIds.get(oldestPath) || [];
-        for (const id of ids) revisionsById.delete(id);
-        fileRevisionIds.delete(oldestPath);
-        latestByFile.delete(oldestPath);
-    }
-}
-
-function rememberRevisionId(filePath, revision) {
-    const ids = fileRevisionIds.get(filePath) || [];
-    ids.push(revision);
-    while (ids.length > MAX_REVISIONS_PER_FILE) {
-        const removed = ids.shift();
-        revisionsById.delete(removed);
-    }
-    fileRevisionIds.set(filePath, ids);
-}
-
-function buildUniqueTagIndex(lineHashes) {
-    const index = new Map();
-    const duplicates = new Set();
-    for (let i = 0; i < lineHashes.length; i++) {
-        const tag = lineTag(lineHashes[i]);
-        if (duplicates.has(tag)) continue;
-        if (index.has(tag)) {
-            index.delete(tag);
-            duplicates.add(tag);
-            continue;
-        }
-        index.set(tag, i);
-    }
-    return index;
-}
-
-function computeFileChecksum(lineHashes) {
-    return rangeChecksum(lineHashes, 1, lineHashes.length);
-}
-
-function diffLineCount(value) {
-    if (!value) return 0;
-    return value.split("\n").length - 1;
-}
-
-function coalesceRanges(ranges) {
-    if (!ranges.length) return [];
-    const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
-    const merged = [sorted[0]];
-    for (let i = 1; i < sorted.length; i++) {
-        const prev = merged[merged.length - 1];
-        const curr = sorted[i];
-        if (curr.start <= prev.end + 1) {
-            prev.end = Math.max(prev.end, curr.end);
-            prev.kind = prev.kind === curr.kind ? prev.kind : "mixed";
-            continue;
-        }
-        merged.push({ ...curr });
-    }
-    return merged;
-}
-
-export function computeChangedRanges(oldLines, newLines) {
-    const oldText = oldLines.join("\n") + "\n";
-    const newText = newLines.join("\n") + "\n";
-    const parts = diffLines(oldText, newText);
-    const ranges = [];
-    let oldNum = 1;
-    let newNum = 1;
-
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const count = diffLineCount(part.value);
-
-        if (part.removed) {
-            const next = parts[i + 1];
-            if (next?.added) {
-                const addedCount = diffLineCount(next.value);
-                ranges.push({
-                    start: newNum,
-                    end: addedCount > 0 ? newNum + addedCount - 1 : newNum,
-                    kind: "replace",
-                });
-                oldNum += count;
-                newNum += addedCount;
-                i++;
-                continue;
-            }
-            ranges.push({ start: newNum, end: newNum, kind: "delete" });
-            oldNum += count;
-            continue;
-        }
-
-        if (part.added) {
-            ranges.push({
-                start: newNum,
-                end: count > 0 ? newNum + count - 1 : newNum,
-                kind: "insert",
-            });
-            newNum += count;
-            continue;
-        }
-
-        oldNum += count;
-        newNum += count;
-    }
-
-    return coalesceRanges(ranges);
-}
-
-export function describeChangedRanges(ranges) {
-    if (!ranges?.length) return "none";
-    return ranges.map(r => `${r.start}-${r.end}${r.kind ? `(${r.kind})` : ""}`).join(", ");
-}
-
-function createSnapshot(filePath, content, mtimeMs, size, prevSnapshot = null) {
-    const lines = content.split("\n");
-    const lineHashes = lines.map(line => fnv1a(line));
-    const fileChecksum = computeFileChecksum(lineHashes);
-    const revision = `rev-${++revisionSeq}-${fileChecksum.split(":")[1]}`;
-    return {
-        revision,
-        path: filePath,
-        content,
-        lines,
-        lineHashes,
-        fileChecksum,
-        uniqueTagIndex: buildUniqueTagIndex(lineHashes),
-        changedRangesFromPrev: prevSnapshot ? computeChangedRanges(prevSnapshot.lines, lines) : [],
-        prevRevision: prevSnapshot?.revision || null,
-        mtimeMs,
-        size,
-        createdAt: Date.now(),
-    };
-}
-
-export function rememberSnapshot(filePath, content, meta = {}) {
-    pruneExpired();
-    const latest = latestByFile.get(filePath);
-    const mtimeMs = meta.mtimeMs ?? latest?.mtimeMs ?? Date.now();
-    const size = meta.size ?? Buffer.byteLength(content, "utf8");
-
-    if (latest && latest.content === content && latest.mtimeMs === mtimeMs && latest.size === size) {
-        touchFile(filePath);
-        return latest;
-    }
-
-    const snapshot = createSnapshot(filePath, content, mtimeMs, size, latest || null);
-    latestByFile.set(filePath, snapshot);
-    revisionsById.set(snapshot.revision, snapshot);
-    rememberRevisionId(filePath, snapshot.revision);
-    touchFile(filePath);
-    pruneExpired();
-    return snapshot;
-}
-
-export function readSnapshot(filePath) {
-    pruneExpired();
-    const stat = statSync(filePath);
-    const latest = latestByFile.get(filePath);
-    if (latest && latest.mtimeMs === stat.mtimeMs && latest.size === stat.size) {
-        touchFile(filePath);
-        return latest;
-    }
-    const content = readText(filePath);
-    return rememberSnapshot(filePath, content, { mtimeMs: stat.mtimeMs, size: stat.size });
-}
-
-export function getLatestSnapshot(filePath) {
-    pruneExpired();
-    const latest = latestByFile.get(filePath);
-    if (!latest) return null;
-    touchFile(filePath);
-    return latest;
-}
-
-export function getSnapshotByRevision(revision) {
-    pruneExpired();
-    return revisionsById.get(revision) || null;
-}
-
-export function overlapsChangedRanges(ranges, startLine, endLine) {
-    return (ranges || []).some((range) => range.start <= endLine && startLine <= range.end);
-}
-
-export function buildRangeChecksum(snapshot, startLine, endLine) {
-    const startIdx = startLine - 1;
-    const endIdx = endLine - 1;
-    if (startIdx < 0 || endIdx >= snapshot.lineHashes.length || startIdx > endIdx) return null;
-    return rangeChecksum(snapshot.lineHashes.slice(startIdx, endIdx + 1), startLine, endLine);
-}
-
-export function _resetRevisionCache() {
-    latestByFile.clear();
-    revisionsById.clear();
-    fileRevisionIds.clear();
-    revisionSeq = 0;
-}

package/lib/search.mjs

@@ -1,268 +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 "@levnikolaevich/hex-common/text-protocol/hash";
-import { getGraphDB, matchAnnotation, getRelativePath } from "./graph-enrich.mjs";
-import { normalizePath } from "./security.mjs";
-
-let rgBin = "rg";
-try { rgBin = (await import("@vscode/ripgrep")).rgPath; } catch { /* system rg */ }
-
-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(rgBin, 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) => {
-            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\`\`\``;
-}

package/lib/security.mjs

@@ -1,112 +0,0 @@
-/**
- * Security boundaries for file operations.
- *
- * Claude Code provides its own sandbox (permissions, project scope).
- * This module handles: path canonicalization, symlink resolution,
- * binary file detection, and size limits.
- */
-
-import { realpathSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
-import { resolve, isAbsolute, dirname } from "node:path";
-import { listDirectory } from "./format.mjs";
-
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
-
-/**
- * Convert Git Bash /c/Users/... → c:/Users/... on Windows.
- * Node.js resolve() treats /c/ as absolute from current drive root, producing D:\c\Users.
- */
-export function normalizePath(p) {
-    if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
-        p = p[1] + ":" + p.slice(2);
-    }
-    return p.replace(/\\/g, "/");
-}
-
-/**
- * Validate a file path against security boundaries.
- * Returns the canonicalized absolute path.
- * Throws on violation.
- */
-export function validatePath(filePath) {
-    if (!filePath) throw new Error("Empty file path");
-
-    const normalized = normalizePath(filePath);
-    const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
-
-    // Check existence — show parent directory contents as fallback
-    if (!existsSync(abs)) {
-        let hint = "";
-        try {
-            const parent = dirname(abs);
-            if (existsSync(parent)) {
-                const { text, total } = listDirectory(parent, { limit: 20, metadata: true });
-                hint = `\n\nParent directory ${parent} contains:\n${text}`;
-                if (total > 20) hint += `\n  ... (${total - 20} more)`;
-            }
-        } catch {}
-        throw new Error(`FILE_NOT_FOUND: ${abs}${hint}`);
-    }
-
-    // Canonicalize (resolves symlinks)
-    let real;
-    try {
-        real = realpathSync(abs);
-    } catch (e) {
-        throw new Error(`Cannot resolve path: ${abs} (${e.message})`);
-    }
-
-    // Check file type
-    const stat = statSync(real);
-    if (stat.isDirectory()) return real; // directories allowed for listing
-    if (!stat.isFile()) {
-        const type = stat.isSymbolicLink() ? "symlink" : "special";
-        throw new Error(`NOT_REGULAR_FILE: ${real} (${type}). Cannot read special files.`);
-    }
-
-    // Size check
-    if (stat.size > MAX_FILE_SIZE) {
-        throw new Error(`FILE_TOO_LARGE: ${real} (${(stat.size / 1024 / 1024).toFixed(1)}MB, max ${MAX_FILE_SIZE / 1024 / 1024}MB). Use offset/limit to read a range.`);
-    }
-
-    // Binary detection (check first 8KB for null bytes — only read 8KB, not whole file)
-    const bfd = openSync(real, "r");
-    const probe = Buffer.alloc(8192);
-    const bytesRead = readSync(bfd, probe, 0, 8192, 0);
-    closeSync(bfd);
-    for (let i = 0; i < bytesRead; i++) {
-        if (probe[i] === 0) {
-            throw new Error(`BINARY_FILE: ${real}. Use built-in Read tool (supports images, PDFs, notebooks).`);
-        }
-    }
-
-    return real.replace(/\\/g, "/");
-}
-
-/**
- * Validate path for write (does NOT require file to exist).
- * Resolves to absolute path, validates parent exists or can be created.
- */
-export function validateWritePath(filePath) {
-    if (!filePath) throw new Error("Empty file path");
-
-    const normalized = normalizePath(filePath);
-    const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
-
-    // For write, the file might not exist yet — validate the parent directory
-    if (!existsSync(abs)) {
-        const parent = resolve(abs, "..");
-        if (!existsSync(parent)) {
-            // Walk up to find an existing ancestor (parent dirs will be created by write_file)
-            let ancestor = resolve(parent, "..");
-            while (!existsSync(ancestor) && ancestor !== resolve(ancestor, "..")) {
-                ancestor = resolve(ancestor, "..");
-            }
-            if (!existsSync(ancestor)) {
-                throw new Error(`No existing ancestor directory for: ${abs}`);
-            }
-        }
-    }
-
-    return abs.replace(/\\/g, "/");
-}