@levnikolaevich/hex-line-mcp 1.2.0 → 1.3.1

package/lib/search.mjs

@@ -1,47 +1,35 @@
 /**
  * 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 } from "./hash.mjs";
+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
 
+
+
 /**
- * Search files using ripgrep.
- *
- * @param {string} pattern - regex pattern
- * @param {object} opts - { path, glob, type, caseInsensitive, context, limit, plain }
- * @returns {Promise<string>} formatted results
+ * Spawn ripgrep and collect stdout.
+ * Returns { stdout, code, stderr, killed }.
  */
-export function grepSearch(pattern, opts = {}) {
+function spawnRg(args) {
     return new Promise((resolve_, reject) => {
-        // Convert Git Bash /c/path → c:/path on Windows
-        const rawPath = opts.path || "";
-        const normPath = (process.platform === "win32" && /^\/[a-zA-Z]\//.test(rawPath))
-            ? rawPath[1] + ":" + rawPath.slice(2) : rawPath;
-        const target = normPath ? resolve(normPath) : process.cwd();
-        const args = ["-n", "--no-heading", "--with-filename"];
-        const plain = !!opts.plain;
-
-        if (opts.caseInsensitive) args.push("-i");
-        else if (opts.smartCase) args.push("-S");
-        if (opts.context && opts.context > 0) args.push("-C", String(opts.context));
-        if (opts.glob) args.push("--glob", opts.glob);
-        if (opts.type) args.push("--type", opts.type);
-
-        const limit = (opts.limit && opts.limit > 0) ? opts.limit : DEFAULT_LIMIT;
-        args.push("-m", String(limit));
-        args.push("--", pattern, target);
-
         let stdout = "";
         let totalBytes = 0;
         let killed = false;
+        let stderrBuf = "";
 
         const child = spawn("rg", args, { timeout: TIMEOUT });
 
@@ -55,7 +43,6 @@ export function grepSearch(pattern, opts = {}) {
             stdout += chunk.toString("utf-8");
         });
 
-        let stderrBuf = "";
         child.stderr.on("data", (chunk) => { stderrBuf += chunk.toString("utf-8"); });
 
         child.on("error", (err) => {
@@ -67,67 +54,216 @@ export function grepSearch(pattern, opts = {}) {
         });
 
         child.on("close", (code) => {
-            if (killed) {
-                resolve_("GREP_OUTPUT_TRUNCATED: exceeded 10MB. Use specific glob/path.");
-                return;
-            }
-            if (code === 1) {
-                resolve_("No matches found.");
-                return;
+            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 (code !== 0 && code !== null) {
-                const reason = stderrBuf.trim() || "unknown error";
-                reject(new Error(`GREP_ERROR: rg exit ${code} — ${reason}`));
-                return;
+            if (msg.type === "begin") {
+                // Separator between file groups
+                if (formatted.length > 0 && formatted[formatted.length - 1] !== "") {
+                    formatted.push("");
+                }
             }
+            continue;
+        }
 
-            // Format results with hash tags
-            const resultLines = stdout.trimEnd().split("\n");
-            const formatted = [];
-            const db = getGraphDB(target);
-            const relCache = new Map();
+        if (msg.type !== "match" && msg.type !== "context") continue;
 
-            // Match line: file:42:content
-            const matchRe = /^((?:[A-Za-z]:)?[^:]*):(\d+):(.*)$/;
-            // Context line: file-42-content
-            const ctxRe = /^((?:[A-Za-z]:)?[^-]*)-(\d+)-(.*)$/;
+        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) {
-                // Plain mode: file:line:content without hash tags
-                for (const rl of resultLines) {
-                    formatted.push(rl);
-                }
+                formatted.push(`${filePath}:${ln}:${lineContent}`);
             } else {
-                for (const rl of resultLines) {
-                    if (!rl || rl === "--") { formatted.push(rl); continue; }
-                    // Normalize backslashes for consistent regex matching on Windows
-                    const nl = rl.replace(/\\/g, "/");
-
-                    const m = matchRe.exec(nl);
-                    if (m) {
-                        const tag = lineTag(fnv1a(m[3]));
-                        let anno = "";
-                        if (db) {
-                            let rel = relCache.get(m[1]);
-                            if (rel === undefined) { rel = getRelativePath(resolve(m[1])) || ""; relCache.set(m[1], rel); }
-                            if (rel) { const a = matchAnnotation(db, rel, +m[2]); if (a) anno = `  ${a}`; }
-                        }
-                        formatted.push(`${m[1]}:>>${tag}.${m[2]}\t${m[3]}${anno}`);
-                        continue;
+                let anno = "";
+                if (db && isMatch) {
+                    let rel = relCache.get(filePath);
+                    if (rel === undefined) {
+                        rel = getRelativePath(resolve(filePath)) || "";
+                        relCache.set(filePath, rel);
                     }
-
-                    const c = ctxRe.exec(nl);
-                    if (c) {
-                        const tag = lineTag(fnv1a(c[3]));
-                        formatted.push(`${c[1]}:  ${tag}.${c[2]}\t${c[3]}`);
-                        continue;
+                    if (rel) {
+                        const a = matchAnnotation(db, rel, ln);
+                        if (a) anno = `  ${a}`;
                     }
-
-                    formatted.push(rl);
                 }
+                const prefix = isMatch ? ">>" : "  ";
+                formatted.push(`${filePath}:${prefix}${tag}.${ln}\t${lineContent}${anno}`);
             }
 
-            resolve_(`\`\`\`\n${formatted.join("\n")}\n\`\`\``);
-        });
-    });
+        }
+
+        // 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

@@ -6,8 +6,9 @@
  * binary file detection, and size limits.
  */
 
-import { realpathSync, statSync, existsSync, readdirSync, openSync, readSync, closeSync } from "node:fs";
+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
 
@@ -15,7 +16,7 @@ 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.
  */
-function normalizePath(p) {
+export function normalizePath(p) {
     if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
         return p[1] + ":" + p.slice(2);
     }
@@ -39,12 +40,9 @@ export function validatePath(filePath) {
         try {
             const parent = dirname(abs);
             if (existsSync(parent)) {
-                const entries = readdirSync(parent, { withFileTypes: true });
-                const listing = entries.slice(0, 20).map(e =>
-                    `  ${e.isDirectory() ? "d" : "f"} ${e.name}`
-                ).join("\n");
-                hint = `\n\nParent directory ${parent} contains:\n${listing}`;
-                if (entries.length > 20) hint += `\n  ... (${entries.length - 20} more)`;
+                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}`);

package/lib/setup.mjs

@@ -18,9 +18,6 @@ const __dirname = dirname(__filename);
 const HOOK_SCRIPT = resolve(__dirname, "..", "hook.mjs").replace(/\\/g, "/");
 const HOOK_COMMAND = `node ${HOOK_SCRIPT}`;
 
-// Legacy relative command — needed to find and remove old per-project hooks.
-const OLD_HOOK_COMMAND = "node mcp/hex-line-mcp/hook.mjs";
-
 // Substring that identifies any hex-line hook command (old relative or new absolute).
 const HOOK_SIGNATURE = "hex-line-mcp/hook.mjs";
 
@@ -36,7 +33,7 @@ const CLAUDE_HOOKS = {
         hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }],
     },
     PreToolUse: {
-        matcher: "Read|Edit|Write|Grep|Bash",
+        matcher: "Read|Edit|Write|Grep|Bash|mcp__hex-line__.*",
         hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }],
     },
     PostToolUse: {
@@ -230,6 +227,34 @@ function setupCodex() {
     return "Codex: Not supported (Codex CLI does not support hooks. Add MCP Tool Preferences to AGENTS.md instead)";
 }
 
+// ---- Uninstall: remove hex-line hooks ----
+
+function uninstallClaude() {
+    const globalPath = resolve(homedir(), ".claude/settings.json");
+    const config = readJson(globalPath);
+    if (!config || !config.hooks || typeof config.hooks !== "object") {
+        return "Claude: no hooks to remove";
+    }
+
+    let changed = false;
+    for (const event of Object.keys(CLAUDE_HOOKS)) {
+        if (!Array.isArray(config.hooks[event])) continue;
+        const idx = findEntryByCommand(config.hooks[event]);
+        if (idx >= 0) {
+            config.hooks[event].splice(idx, 1);
+            if (config.hooks[event].length === 0) delete config.hooks[event];
+            changed = true;
+        }
+    }
+
+    if (Object.keys(config.hooks).length === 0) delete config.hooks;
+
+    if (!changed) return "Claude: no hex-line hooks found";
+
+    writeJson(globalPath, config);
+    return "Claude: hex-line hooks removed from global settings";
+}
+
 // ---- Public API ----
 
 const AGENTS = { claude: setupClaude, gemini: setupGemini, codex: setupCodex };
@@ -238,10 +263,17 @@ const AGENTS = { claude: setupClaude, gemini: setupGemini, codex: setupCodex };
  * Configure hex-line hooks for one or all supported agents.
  * Claude: writes to ~/.claude/settings.json (global), cleans per-project hooks.
  * @param {string} [agent="all"] - "claude", "gemini", "codex", or "all"
+ * @param {string} [action="install"] - "install" or "uninstall"
  * @returns {string} Status report
  */
-export function setupHooks(agent = "all") {
+export function setupHooks(agent = "all", action = "install") {
     const target = (agent || "all").toLowerCase();
+    const act = (action || "install").toLowerCase();
+
+    if (act === "uninstall") {
+        const result = uninstallClaude();
+        return `Hooks uninstalled:\n  ${result}\n\nRestart Claude Code to apply changes.`;
+    }
 
     if (target !== "all" && !AGENTS[target]) {
         throw new Error(`UNKNOWN_AGENT: '${agent}'. Supported: claude, gemini, codex, all`);