@levnikolaevich/hex-line-mcp 1.3.3 → 1.3.5

package/dist/server.mjs

@@ -0,0 +1,2645 @@
+#!/usr/bin/env node
+
+// server.mjs
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+import { z as z2 } from "zod";
+
+// ../hex-common/src/runtime/mcp-bootstrap.mjs
+async function createServerRuntime({ name, version: version2, installDir }) {
+  let McpServer, StdioServerTransport2;
+  try {
+    ({ McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js"));
+    ({ StdioServerTransport: StdioServerTransport2 } = await import("@modelcontextprotocol/sdk/server/stdio.js"));
+  } catch {
+    process.stderr.write(
+      `${name}: @modelcontextprotocol/sdk not found.
+Run: cd ${installDir} && npm install
+`
+    );
+    process.exit(1);
+  }
+  return {
+    server: new McpServer({ name, version: version2 }),
+    StdioServerTransport: StdioServerTransport2
+  };
+}
+
+// ../hex-common/src/runtime/schema.mjs
+import { z } from "zod";
+var flexBool = () => z.preprocess(
+  (v) => typeof v === "string" ? v === "true" : v,
+  z.boolean().optional()
+).optional();
+var flexNum = () => z.preprocess(
+  (v) => typeof v === "string" ? Number(v) : v,
+  z.number().optional()
+).optional();
+
+// ../hex-common/src/runtime/coerce.mjs
+function coerceParams(params) {
+  return params;
+}
+
+// ../hex-common/src/runtime/update-check.mjs
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+var CACHE_FILE = join(tmpdir(), "hex-common-update.json");
+var CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+var TIMEOUT = 3e3;
+async function readCache() {
+  try {
+    return JSON.parse(await readFile(CACHE_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeCache(entry) {
+  await writeFile(CACHE_FILE, JSON.stringify(entry)).catch(() => {
+  });
+}
+async function fetchLatest(packageName) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, { signal: ctrl.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+  }
+  return 0;
+}
+async function checkForUpdates(packageName, currentVersion) {
+  const cache = await readCache();
+  const cached = cache[packageName];
+  if (cached && Date.now() - cached.timestamp < CHECK_INTERVAL) {
+    if (cached.latest && compareVersions(currentVersion, cached.latest) < 0) {
+      process.stderr.write(`${packageName} update: ${currentVersion} -> ${cached.latest}. Run: npm install -g ${packageName}
+`);
+    }
+    return;
+  }
+  const latest = await fetchLatest(packageName);
+  if (!latest) return;
+  cache[packageName] = { timestamp: Date.now(), latest };
+  await writeCache(cache);
+  if (compareVersions(currentVersion, latest) < 0) {
+    process.stderr.write(`${packageName} update: ${currentVersion} -> ${latest}. Run: npm install -g ${packageName}
+`);
+  }
+}
+
+// lib/read.mjs
+import { statSync as statSync4 } from "node:fs";
+
+// ../hex-common/src/text-protocol/hash.mjs
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+var TAG_CHARS = "abcdefghijklmnopqrstuvwxyz234567";
+function fnv1a(str) {
+  const normalized = str.replace(/\r$/, "").replace(/\s+/g, "");
+  let h = FNV_OFFSET;
+  for (let i = 0; i < normalized.length; i++) {
+    let code = normalized.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < normalized.length) {
+      const lo = normalized.charCodeAt(i + 1);
+      if (lo >= 56320 && lo <= 57343) {
+        code = (code - 55296 << 10) + (lo - 56320) + 65536;
+        i++;
+      }
+    }
+    if (code < 128) {
+      h = Math.imul(h ^ code, FNV_PRIME) >>> 0;
+    } else if (code < 2048) {
+      h = Math.imul(h ^ (192 | code >> 6), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code & 63), FNV_PRIME) >>> 0;
+    } else if (code < 65536) {
+      h = Math.imul(h ^ (224 | code >> 12), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code >> 6 & 63), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code & 63), FNV_PRIME) >>> 0;
+    } else {
+      h = Math.imul(h ^ (240 | code >> 18), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code >> 12 & 63), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code >> 6 & 63), FNV_PRIME) >>> 0;
+      h = Math.imul(h ^ (128 | code & 63), FNV_PRIME) >>> 0;
+    }
+  }
+  return h;
+}
+function lineTag(hash32) {
+  return TAG_CHARS[hash32 & 31] + TAG_CHARS[hash32 >>> 8 & 31];
+}
+function rangeChecksum(lineHashes, startLine, endLine) {
+  let acc = FNV_OFFSET;
+  for (const h of lineHashes) {
+    acc = Math.imul(acc ^ h & 255, FNV_PRIME) >>> 0;
+    acc = Math.imul(acc ^ h >>> 8 & 255, FNV_PRIME) >>> 0;
+    acc = Math.imul(acc ^ h >>> 16 & 255, FNV_PRIME) >>> 0;
+    acc = Math.imul(acc ^ h >>> 24 & 255, FNV_PRIME) >>> 0;
+  }
+  return `${startLine}-${endLine}:${acc.toString(16).padStart(8, "0")}`;
+}
+function parseRef(ref) {
+  const m = ref.trim().match(/^([a-z2-7]{2})\.(\d+)$/);
+  if (!m) throw new Error(`Bad ref: "${ref}". Expected "ab.12" (tag.lineNum)`);
+  return { tag: m[1], line: parseInt(m[2], 10) };
+}
+function parseChecksum(cs) {
+  const m = cs.trim().match(/^(\d+)-(\d+):([0-9a-f]{8})$/);
+  if (!m) throw new Error(`Bad checksum: "${cs}". Expected "1-50:f7e2a1b0"`);
+  return { start: parseInt(m[1], 10), end: parseInt(m[2], 10), hex: m[3] };
+}
+
+// lib/security.mjs
+import { realpathSync, statSync as statSync2, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { resolve, isAbsolute, dirname } from "node:path";
+
+// lib/format.mjs
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${bytes}B`;
+}
+function relativeTime(date, compact = false) {
+  const sec = Math.round((Date.now() - date.getTime()) / 1e3);
+  if (compact) {
+    if (sec < 60) return "now";
+    if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
+    if (sec < 86400) return `${Math.floor(sec / 3600)}h ago`;
+    if (sec < 604800) return `${Math.floor(sec / 86400)}d ago`;
+    if (sec < 2592e3) return `${Math.floor(sec / 604800)}w ago`;
+    return `${Math.floor(sec / 2592e3)}mo ago`;
+  }
+  if (sec < 60) return "just now";
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min} min ago`;
+  const hrs = Math.floor(min / 60);
+  if (hrs < 24) return `${hrs} hour${hrs === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hrs / 24);
+  if (days < 30) return `${days} day${days === 1 ? "" : "s"} ago`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months} month${months === 1 ? "" : "s"} ago`;
+  const years = Math.floor(months / 12);
+  return `${years} year${years === 1 ? "" : "s"} ago`;
+}
+function countFileLines(filePath, size, maxSize = 1e6) {
+  if (size === 0 || size > maxSize) return null;
+  try {
+    const buf = readFileSync(filePath);
+    const checkLen = Math.min(buf.length, 8192);
+    for (let i = 0; i < checkLen; i++) if (buf[i] === 0) return null;
+    let count = 1;
+    for (let i = 0; i < buf.length; i++) if (buf[i] === 10) count++;
+    return count;
+  } catch {
+    return null;
+  }
+}
+function listDirectory(dirPath, opts = {}) {
+  const { limit = 0, metadata = false, compact = false, indent = "  " } = opts;
+  let entries;
+  try {
+    entries = readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return { text: "", total: 0 };
+  }
+  entries.sort((a, b) => {
+    const aDir = a.isDirectory() ? 0 : 1;
+    const bDir = b.isDirectory() ? 0 : 1;
+    if (aDir !== bDir) return aDir - bDir;
+    return a.name.localeCompare(b.name);
+  });
+  const total = entries.length;
+  const visible = limit > 0 ? entries.slice(0, limit) : entries;
+  const lines = visible.map((entry) => {
+    const isDir = entry.isDirectory();
+    if (!metadata) {
+      return `${indent}${isDir ? "d" : "f"} ${entry.name}`;
+    }
+    if (isDir) {
+      return `${indent}${entry.name}/`;
+    }
+    const full = join2(dirPath, entry.name);
+    const parts = [];
+    try {
+      const st = statSync(full);
+      const lineCount = countFileLines(full, st.size);
+      if (lineCount !== null) parts.push(`${lineCount}L`);
+      parts.push(formatSize(st.size));
+      if (st.mtime) parts.push(relativeTime(st.mtime, compact));
+    } catch {
+      parts.push("?");
+    }
+    return `${indent}${entry.name} (${parts.join(", ")})`;
+  });
+  return { text: lines.join("\n"), total };
+}
+var MAX_OUTPUT_CHARS = 8e4;
+function readText(filePath) {
+  return readFileSync(filePath, "utf-8").replace(/\r\n/g, "\n");
+}
+
+// lib/security.mjs
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+function normalizePath(p) {
+  if (process.platform === "win32" && /^\/[a-zA-Z]\//.test(p)) {
+    p = p[1] + ":" + p.slice(2);
+  }
+  return p.replace(/\\/g, "/");
+}
+function validatePath(filePath) {
+  if (!filePath) throw new Error("Empty file path");
+  const normalized = normalizePath(filePath);
+  const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
+  if (!existsSync(abs)) {
+    let hint = "";
+    try {
+      const parent = dirname(abs);
+      if (existsSync(parent)) {
+        const { text, total } = listDirectory(parent, { limit: 20, metadata: true });
+        hint = `
+
+Parent directory ${parent} contains:
+${text}`;
+        if (total > 20) hint += `
+  ... (${total - 20} more)`;
+      }
+    } catch {
+    }
+    throw new Error(`FILE_NOT_FOUND: ${abs}${hint}`);
+  }
+  let real;
+  try {
+    real = realpathSync(abs);
+  } catch (e) {
+    throw new Error(`Cannot resolve path: ${abs} (${e.message})`);
+  }
+  const stat = statSync2(real);
+  if (stat.isDirectory()) return real;
+  if (!stat.isFile()) {
+    const type = stat.isSymbolicLink() ? "symlink" : "special";
+    throw new Error(`NOT_REGULAR_FILE: ${real} (${type}). Cannot read special files.`);
+  }
+  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.`);
+  }
+  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, "/");
+}
+function validateWritePath(filePath) {
+  if (!filePath) throw new Error("Empty file path");
+  const normalized = normalizePath(filePath);
+  const abs = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
+  if (!existsSync(abs)) {
+    const parent = resolve(abs, "..");
+    if (!existsSync(parent)) {
+      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, "/");
+}
+
+// lib/graph-enrich.mjs
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join3, dirname as dirname2, relative } from "node:path";
+import { createRequire } from "node:module";
+var HEX_LINE_CONTRACT_VERSION = 1;
+var _dbs = /* @__PURE__ */ new Map();
+var _driverUnavailable = false;
+function getGraphDB(filePath) {
+  if (_driverUnavailable) return null;
+  try {
+    const projectRoot = findProjectRoot(filePath);
+    if (!projectRoot) return null;
+    const dbPath = join3(projectRoot, ".codegraph", "index.db");
+    if (!existsSync2(dbPath)) return null;
+    if (_dbs.has(dbPath)) return _dbs.get(dbPath);
+    const require2 = createRequire(import.meta.url);
+    const Database = require2("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;
+  }
+}
+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;
+  }
+}
+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;
+  }
+}
+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 [];
+  }
+}
+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 = /* @__PURE__ */ 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 [];
+  }
+}
+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;
+  }
+}
+function getRelativePath(filePath) {
+  const root = findProjectRoot(filePath);
+  if (!root) return null;
+  return relative(root, filePath).replace(/\\/g, "/");
+}
+function findProjectRoot(filePath) {
+  let dir = dirname2(filePath);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join3(dir, ".codegraph", "index.db"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  dir = dirname2(filePath);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join3(dir, ".git"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// lib/revisions.mjs
+import { statSync as statSync3 } from "node:fs";
+import { diffLines } from "diff";
+var MAX_FILES = 200;
+var MAX_REVISIONS_PER_FILE = 5;
+var TTL_MS = 5 * 60 * 1e3;
+var latestByFile = /* @__PURE__ */ new Map();
+var revisionsById = /* @__PURE__ */ new Map();
+var fileRevisionIds = /* @__PURE__ */ new Map();
+var 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 = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ 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;
+}
+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);
+}
+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()
+  };
+}
+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;
+}
+function readSnapshot(filePath) {
+  pruneExpired();
+  const stat = statSync3(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 });
+}
+function getSnapshotByRevision(revision) {
+  pruneExpired();
+  return revisionsById.get(revision) || null;
+}
+function overlapsChangedRanges(ranges, startLine, endLine) {
+  return (ranges || []).some((range) => range.start <= endLine && startLine <= range.end);
+}
+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);
+}
+
+// lib/read.mjs
+var DEFAULT_LIMIT = 2e3;
+function readFile2(filePath, opts = {}) {
+  filePath = normalizePath(filePath);
+  const real = validatePath(filePath);
+  const stat = statSync4(real);
+  if (stat.isDirectory()) {
+    const { text } = listDirectory(real, { metadata: true });
+    return `Directory: ${filePath}
+
+\`\`\`
+${text}
+\`\`\``;
+  }
+  const snapshot = rememberSnapshot(real, readText(real), { mtimeMs: stat.mtimeMs, size: stat.size });
+  const lines = snapshot.lines;
+  const total = lines.length;
+  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}	${line}`;
+      if (charCount + entry.length > MAX_OUTPUT_CHARS && formatted.length > 0) {
+        cappedAtLine = num;
+        break;
+      }
+      lineHashes.push(hash32);
+      formatted.push(entry);
+      charCount += entry.length + 1;
+    }
+    const actualEnd = formatted.length > 0 ? range.start + formatted.length - 1 : range.start;
+    range.end = actualEnd;
+    parts.push(formatted.join("\n"));
+    const cs = rangeChecksum(lineHashes, range.start, actualEnd);
+    parts.push(`
+checksum: ${cs}`);
+    if (cappedAtLine) break;
+  }
+  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)`;
+    }
+  }
+  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 = `
+Graph: ${items.join(" | ")}`;
+    }
+  }
+  let result = `${header}${graphLine}
+revision: ${snapshot.revision}
+file: ${snapshot.fileChecksum}
+
+\`\`\`
+${parts.join("\n")}
+\`\`\``;
+  if (total > 200 && (!opts.offset || opts.offset <= 1) && !cappedAtLine) {
+    result += `
+
+\u26A1 Tip: This file has ${total} lines. Use outline first, then read_file with offset/limit for 75% fewer tokens.`;
+  }
+  if (cappedAtLine) {
+    result += `
+
+OUTPUT_CAPPED at line ${cappedAtLine} (${MAX_OUTPUT_CHARS} char limit). Use offset=${cappedAtLine} to continue reading.`;
+  }
+  return result;
+}
+
+// lib/edit.mjs
+import { statSync as statSync5, writeFileSync } from "node:fs";
+import { diffLines as diffLines2 } from "diff";
+function restoreIndent(origLines, newLines) {
+  if (!origLines.length || !newLines.length) return newLines;
+  const origIndent = origLines[0].match(/^\s*/)[0];
+  const newIndent = newLines[0].match(/^\s*/)[0];
+  if (origIndent === newIndent) return newLines;
+  return newLines.map((line) => {
+    if (!line.trim()) return line;
+    if (line.startsWith(newIndent)) return origIndent + line.slice(newIndent.length);
+    return line;
+  });
+}
+function buildErrorSnippet(lines, centerIdx, radius = 5) {
+  const start = Math.max(0, centerIdx - radius);
+  const end = Math.min(lines.length, centerIdx + radius + 1);
+  const text = lines.slice(start, end).map((line, i) => {
+    const num = start + i + 1;
+    const tag = lineTag(fnv1a(line));
+    return `${tag}.${num}	${line}`;
+  }).join("\n");
+  return { start: start + 1, end, text };
+}
+function findLine(lines, lineNum, expectedTag, hashIndex) {
+  const idx = lineNum - 1;
+  if (idx < 0 || idx >= lines.length) {
+    const center = idx >= lines.length ? lines.length - 1 : 0;
+    const snip2 = buildErrorSnippet(lines, center);
+    throw new Error(
+      `Line ${lineNum} out of range (1-${lines.length}).
+
+Current content (lines ${snip2.start}-${snip2.end}):
+${snip2.text}
+
+Tip: Use updated hashes above for retry.`
+    );
+  }
+  const actual = lineTag(fnv1a(lines[idx]));
+  if (actual === expectedTag) return idx;
+  for (let d = 1; d <= 5; d++) {
+    for (const off of [d, -d]) {
+      const c = idx + off;
+      if (c >= 0 && c < lines.length && lineTag(fnv1a(lines[c])) === expectedTag) return c;
+    }
+  }
+  const stripped = lines[idx].replace(/\s+/g, "");
+  if (stripped.length > 0) {
+    for (let j = Math.max(0, idx - 5); j <= Math.min(lines.length - 1, idx + 5); j++) {
+      if (lines[j].replace(/\s+/g, "") === stripped && lineTag(fnv1a(lines[j])) === expectedTag) return j;
+    }
+  }
+  const CONFUSABLE_RE = /[\u2010\u2011\u2012\u2013\u2014\u2212\uFE63\uFF0D]/g;
+  const norm = (t) => t.replace(CONFUSABLE_RE, "-");
+  const normalizedExpected = norm(expectedTag);
+  for (let i = Math.max(0, idx - 10); i <= Math.min(lines.length - 1, idx + 10); i++) {
+    const normalizedActual = norm(lineTag(fnv1a(norm(lines[i]))));
+    if (normalizedActual === normalizedExpected) return i;
+  }
+  if (hashIndex) {
+    const relocated = hashIndex.get(expectedTag);
+    if (relocated !== void 0) return relocated;
+  }
+  const snip = buildErrorSnippet(lines, idx);
+  throw new Error(
+    `HASH_MISMATCH: line ${lineNum} expected ${expectedTag}, got ${actual}.
+
+Current content (lines ${snip.start}-${snip.end}):
+${snip.text}
+
+Tip: Use updated hashes above for retry.`
+  );
+}
+function simpleDiff(oldLines, newLines, ctx = 3) {
+  const oldText = oldLines.join("\n") + "\n";
+  const newText = newLines.join("\n") + "\n";
+  const parts = diffLines2(oldText, newText);
+  const out = [];
+  let oldNum = 1, newNum = 1;
+  let lastChange = false;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const lines = part.value.replace(/\n$/, "").split("\n");
+    if (part.added || part.removed) {
+      for (const line of lines) {
+        if (part.removed) {
+          out.push(`-${oldNum}| ${line}`);
+          oldNum++;
+        } else {
+          out.push(`+${newNum}| ${line}`);
+          newNum++;
+        }
+      }
+      lastChange = true;
+    } else {
+      const next = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+      if (lastChange || next) {
+        let start = 0, end = lines.length;
+        if (!lastChange) start = Math.max(0, end - ctx);
+        if (!next && end - start > ctx) end = start + ctx;
+        if (start > 0) {
+          out.push("...");
+          oldNum += start;
+          newNum += start;
+        }
+        for (let k = start; k < end; k++) {
+          out.push(` ${oldNum}| ${lines[k]}`);
+          oldNum++;
+          newNum++;
+        }
+        if (end < lines.length) {
+          out.push("...");
+          oldNum += lines.length - end;
+          newNum += lines.length - end;
+        }
+      } else {
+        oldNum += lines.length;
+        newNum += lines.length;
+      }
+      lastChange = false;
+    }
+  }
+  return out.length ? out.join("\n") : null;
+}
+function verifyChecksumAgainstSnapshot(snapshot, rc) {
+  const { start, end, hex } = parseChecksum(rc);
+  const actual = buildRangeChecksum(snapshot, start, end);
+  if (!actual) return { ok: false, actual: null, start, end };
+  return { ok: actual.split(":")[1] === hex, actual, start, end };
+}
+function buildConflictMessage({
+  filePath,
+  reason,
+  revision,
+  fileChecksum,
+  lines,
+  centerIdx,
+  changedRanges,
+  retryChecksum,
+  details
+}) {
+  const safeCenter = Math.max(0, Math.min(lines.length - 1, centerIdx));
+  const snip = buildErrorSnippet(lines, safeCenter);
+  let msg = `status: CONFLICT
+reason: ${reason}
+revision: ${revision}
+file: ${fileChecksum}`;
+  if (changedRanges) msg += `
+changed_ranges: ${describeChangedRanges(changedRanges)}`;
+  if (retryChecksum) msg += `
+retry_checksum: ${retryChecksum}`;
+  msg += `
+
+${details}
+
+Current content (lines ${snip.start}-${snip.end}):
+${snip.text}`;
+  msg += `
+
+Tip: Retry from the fresh local snippet above.`;
+  if (filePath) msg += `
+path: ${filePath}`;
+  return msg;
+}
+function targetRangeForReplaceBetween(startIdx, endIdx, boundaryMode) {
+  if (boundaryMode === "exclusive") {
+    return { start: startIdx + 2, end: Math.max(startIdx + 1, endIdx) };
+  }
+  return { start: startIdx + 1, end: endIdx + 1 };
+}
+function editFile(filePath, edits, opts = {}) {
+  filePath = normalizePath(filePath);
+  const real = validatePath(filePath);
+  const currentSnapshot = readSnapshot(real);
+  const baseSnapshot = opts.baseRevision ? getSnapshotByRevision(opts.baseRevision) : null;
+  const hasBaseSnapshot = !!(baseSnapshot && baseSnapshot.path === real);
+  const staleRevision = !!opts.baseRevision && opts.baseRevision !== currentSnapshot.revision;
+  const changedRanges = staleRevision && hasBaseSnapshot ? computeChangedRanges(baseSnapshot.lines, currentSnapshot.lines) : [];
+  const conflictPolicy = opts.conflictPolicy || "conservative";
+  const original = currentSnapshot.content;
+  const lines = [...currentSnapshot.lines];
+  const origLines = [...currentSnapshot.lines];
+  const hadTrailingNewline = original.endsWith("\n");
+  const hashIndex = currentSnapshot.uniqueTagIndex;
+  let autoRebased = false;
+  const anchored = [];
+  for (const e of edits) {
+    if (e.set_line || e.replace_lines || e.insert_after || e.replace_between) anchored.push(e);
+    else if (e.replace) throw new Error("REPLACE_REMOVED: replace is no longer supported in edit_file. Use set_line/replace_lines for single edits, bulk_replace tool for rename/refactor.");
+    else throw new Error(`BAD_INPUT: unknown edit type: ${JSON.stringify(e)}`);
+  }
+  const editTargets = [];
+  for (const e of anchored) {
+    if (e.set_line) {
+      const line = parseRef(e.set_line.anchor).line;
+      editTargets.push({ start: line, end: line });
+    } else if (e.replace_lines) {
+      const s = parseRef(e.replace_lines.start_anchor).line;
+      const en = parseRef(e.replace_lines.end_anchor).line;
+      editTargets.push({ start: s, end: en });
+    } else if (e.insert_after) {
+      const line = parseRef(e.insert_after.anchor).line;
+      editTargets.push({ start: line, end: line, insert: true });
+    } else if (e.replace_between) {
+      const s = parseRef(e.replace_between.start_anchor).line;
+      const en = parseRef(e.replace_between.end_anchor).line;
+      editTargets.push({ start: s, end: en });
+    }
+  }
+  for (let i = 0; i < editTargets.length; i++) {
+    for (let j = i + 1; j < editTargets.length; j++) {
+      const a = editTargets[i], b = editTargets[j];
+      if (a.insert || b.insert) continue;
+      if (a.start <= b.end && b.start <= a.end) {
+        throw new Error(
+          `OVERLAPPING_EDITS: lines ${a.start}-${a.end} and ${b.start}-${b.end} overlap. Split into separate edit_file calls.`
+        );
+      }
+    }
+  }
+  const sorted = anchored.map((e) => {
+    let sortKey;
+    if (e.set_line) sortKey = parseRef(e.set_line.anchor).line;
+    else if (e.replace_lines) sortKey = parseRef(e.replace_lines.start_anchor).line;
+    else if (e.insert_after) sortKey = parseRef(e.insert_after.anchor).line;
+    else if (e.replace_between) sortKey = parseRef(e.replace_between.start_anchor).line;
+    return { ...e, _k: sortKey };
+  }).sort((a, b) => b._k - a._k);
+  const conflictIfNeeded = (reason, centerIdx, retryChecksum, details) => {
+    if (conflictPolicy !== "conservative") {
+      throw new Error(details);
+    }
+    return buildConflictMessage({
+      filePath,
+      reason,
+      revision: currentSnapshot.revision,
+      fileChecksum: currentSnapshot.fileChecksum,
+      lines,
+      centerIdx,
+      changedRanges: staleRevision && hasBaseSnapshot ? changedRanges : null,
+      retryChecksum,
+      details
+    });
+  };
+  const locateOrConflict = (ref, reason = "stale_anchor") => {
+    try {
+      return findLine(lines, ref.line, ref.tag, hashIndex);
+    } catch (e) {
+      if (conflictPolicy !== "conservative" || !staleRevision) throw e;
+      const centerIdx = Math.max(0, Math.min(lines.length - 1, ref.line - 1));
+      return conflictIfNeeded(reason, centerIdx, null, e.message);
+    }
+  };
+  const ensureRevisionContext = (actualStart, actualEnd, centerIdx) => {
+    if (!staleRevision || conflictPolicy !== "conservative") return null;
+    if (!hasBaseSnapshot) {
+      return conflictIfNeeded(
+        "base_revision_evicted",
+        centerIdx,
+        null,
+        `Base revision ${opts.baseRevision} is not available in the local revision cache.`
+      );
+    }
+    if (overlapsChangedRanges(changedRanges, actualStart, actualEnd)) {
+      return conflictIfNeeded(
+        "overlap",
+        centerIdx,
+        null,
+        `Changes since ${opts.baseRevision} overlap edit range ${actualStart}-${actualEnd}.`
+      );
+    }
+    autoRebased = true;
+    return null;
+  };
+  for (const e of sorted) {
+    if (e.set_line) {
+      const { tag, line } = parseRef(e.set_line.anchor);
+      const idx = locateOrConflict({ tag, line });
+      if (typeof idx === "string") return idx;
+      const conflict = ensureRevisionContext(idx + 1, idx + 1, idx);
+      if (conflict) return conflict;
+      const txt = e.set_line.new_text;
+      if (!txt && txt !== 0) {
+        lines.splice(idx, 1);
+      } else {
+        const origLine = [lines[idx]];
+        const raw = String(txt).split("\n");
+        const newLines = opts.restoreIndent ? restoreIndent(origLine, raw) : raw;
+        lines.splice(idx, 1, ...newLines);
+      }
+      continue;
+    }
+    if (e.insert_after) {
+      const { tag, line } = parseRef(e.insert_after.anchor);
+      const idx = locateOrConflict({ tag, line });
+      if (typeof idx === "string") return idx;
+      const conflict = ensureRevisionContext(idx + 1, idx + 1, idx);
+      if (conflict) return conflict;
+      let insertLines = e.insert_after.text.split("\n");
+      if (opts.restoreIndent) insertLines = restoreIndent([lines[idx]], insertLines);
+      lines.splice(idx + 1, 0, ...insertLines);
+      continue;
+    }
+    if (e.replace_lines) {
+      const s = parseRef(e.replace_lines.start_anchor);
+      const en = parseRef(e.replace_lines.end_anchor);
+      const si = locateOrConflict(s);
+      if (typeof si === "string") return si;
+      const ei = locateOrConflict(en);
+      if (typeof ei === "string") return ei;
+      const actualStart = si + 1;
+      const actualEnd = ei + 1;
+      const rc = e.replace_lines.range_checksum;
+      if (!rc) throw new Error("range_checksum required for replace_lines. Read the range first via read_file, then pass its checksum.");
+      if (staleRevision && conflictPolicy === "conservative") {
+        const conflict = ensureRevisionContext(actualStart, actualEnd, si);
+        if (conflict) return conflict;
+        const baseCheck = hasBaseSnapshot ? verifyChecksumAgainstSnapshot(baseSnapshot, rc) : null;
+        if (!baseCheck?.ok) {
+          return conflictIfNeeded(
+            "stale_checksum",
+            si,
+            baseCheck?.actual || null,
+            baseCheck?.actual ? `Provided checksum ${rc} does not match base revision ${opts.baseRevision}.` : `Checksum range from ${rc} is outside the available base revision.`
+          );
+        }
+      } else {
+        const { start: csStart, end: csEnd, hex: csHex } = parseChecksum(rc);
+        if (csStart > actualStart || csEnd < actualEnd) {
+          const snip = buildErrorSnippet(origLines, actualStart - 1);
+          throw new Error(
+            `CHECKSUM_RANGE_GAP: range ${csStart}-${csEnd} does not cover edit range ${actualStart}-${actualEnd}.
+
+Current content (lines ${snip.start}-${snip.end}):
+${snip.text}
+
+Tip: Use updated hashes above for retry.`
+          );
+        }
+        const actual = buildRangeChecksum(currentSnapshot, csStart, csEnd);
+        const actualHex = actual?.split(":")[1];
+        if (!actual || csHex !== actualHex) {
+          const details = `CHECKSUM_MISMATCH: expected ${rc}, got ${actual}. File changed \u2014 re-read lines ${csStart}-${csEnd}.`;
+          if (conflictPolicy === "conservative") {
+            return conflictIfNeeded("stale_checksum", csStart - 1, actual, details);
+          }
+          const snip = buildErrorSnippet(origLines, csStart - 1);
+          throw new Error(
+            `${details}
+
+Current content (lines ${snip.start}-${snip.end}):
+${snip.text}
+
+Retry with fresh checksum ${actual}, or use set_line with hashes above.`
+          );
+        }
+      }
+      const txt = e.replace_lines.new_text;
+      if (!txt && txt !== 0) {
+        lines.splice(si, ei - si + 1);
+      } else {
+        const origRange = lines.slice(si, ei + 1);
+        let newLines = String(txt).split("\n");
+        if (opts.restoreIndent) newLines = restoreIndent(origRange, newLines);
+        lines.splice(si, ei - si + 1, ...newLines);
+      }
+      continue;
+    }
+    if (e.replace_between) {
+      const boundaryMode = e.replace_between.boundary_mode || "inclusive";
+      if (boundaryMode !== "inclusive" && boundaryMode !== "exclusive") {
+        throw new Error(`BAD_INPUT: replace_between boundary_mode must be inclusive or exclusive, got ${boundaryMode}`);
+      }
+      const s = parseRef(e.replace_between.start_anchor);
+      const en = parseRef(e.replace_between.end_anchor);
+      const si = locateOrConflict(s);
+      if (typeof si === "string") return si;
+      const ei = locateOrConflict(en);
+      if (typeof ei === "string") return ei;
+      if (si > ei) {
+        throw new Error(`BAD_INPUT: replace_between start anchor resolves after end anchor (${si + 1} > ${ei + 1})`);
+      }
+      const targetRange = targetRangeForReplaceBetween(si, ei, boundaryMode);
+      const conflict = ensureRevisionContext(targetRange.start, targetRange.end, si);
+      if (conflict) return conflict;
+      const txt = e.replace_between.new_text;
+      let newLines = String(txt ?? "").split("\n");
+      const sliceStart = boundaryMode === "exclusive" ? si + 1 : si;
+      const removeCount = boundaryMode === "exclusive" ? Math.max(0, ei - si - 1) : ei - si + 1;
+      const origRange = lines.slice(sliceStart, sliceStart + removeCount);
+      if (opts.restoreIndent && origRange.length > 0) newLines = restoreIndent(origRange, newLines);
+      if (txt === "" || txt === null) newLines = [];
+      lines.splice(sliceStart, removeCount, ...newLines);
+    }
+  }
+  let content = lines.join("\n");
+  if (hadTrailingNewline && !content.endsWith("\n")) content += "\n";
+  if (!hadTrailingNewline && content.endsWith("\n")) content = content.slice(0, -1);
+  if (original === content) {
+    throw new Error("NOOP_EDIT: File already contains the desired content. No changes needed.");
+  }
+  let diff = simpleDiff(origLines, content.split("\n"));
+  if (diff && diff.length > 8e4) {
+    diff = diff.slice(0, 8e4) + `
+... (diff truncated, ${diff.length} chars total)`;
+  }
+  if (opts.dryRun) {
+    let msg2 = `status: ${autoRebased ? "AUTO_REBASED" : "OK"}
+revision: ${currentSnapshot.revision}
+file: ${currentSnapshot.fileChecksum}
+Dry run: ${filePath} would change (${content.split("\n").length} lines)`;
+    if (staleRevision && hasBaseSnapshot) msg2 += `
+changed_ranges: ${describeChangedRanges(changedRanges)}`;
+    if (diff) msg2 += `
+
+Diff:
+\`\`\`diff
+${diff}
+\`\`\``;
+    return msg2;
+  }
+  writeFileSync(real, content, "utf-8");
+  const nextStat = statSync5(real);
+  const nextSnapshot = rememberSnapshot(real, content, { mtimeMs: nextStat.mtimeMs, size: nextStat.size });
+  let msg = `status: ${autoRebased ? "AUTO_REBASED" : "OK"}
+revision: ${nextSnapshot.revision}
+file: ${nextSnapshot.fileChecksum}`;
+  if (autoRebased && staleRevision && hasBaseSnapshot) {
+    msg += `
+changed_ranges: ${describeChangedRanges(changedRanges)}`;
+  }
+  msg += `
+Updated ${filePath} (${content.split("\n").length} lines)`;
+  if (diff) msg += `
+
+Diff:
+\`\`\`diff
+${diff}
+\`\`\``;
+  try {
+    const db = getGraphDB(real);
+    const relFile = db ? getRelativePath(real) : null;
+    if (db && relFile && diff) {
+      const diffLinesOut = diff.split("\n");
+      let minLine = Infinity, maxLine = 0;
+      for (const dl of diffLinesOut) {
+        const m = dl.match(/^[+-](\d+)\|/);
+        if (m) {
+          const n = +m[1];
+          if (n < minLine) minLine = n;
+          if (n > maxLine) maxLine = n;
+        }
+      }
+      if (minLine <= maxLine) {
+        const affected = callImpact(db, relFile, minLine, maxLine);
+        if (affected.length > 0) {
+          const list = affected.map((a) => `${a.name} (${a.file}:${a.line})`).join(", ");
+          msg += `
+
+\u26A0 Call impact: ${affected.length} callers in other files
+  ${list}`;
+        }
+      }
+    }
+  } catch {
+  }
+  const newLinesAll = content.split("\n");
+  if (diff) {
+    const diffArr = diff.split("\n");
+    let minLine = Infinity, maxLine = 0;
+    for (const dl of diffArr) {
+      const m = dl.match(/^[+-](\d+)\|/);
+      if (m) {
+        const n = +m[1];
+        if (n < minLine) minLine = n;
+        if (n > maxLine) maxLine = n;
+      }
+    }
+    if (minLine <= maxLine) {
+      const ctxStart = Math.max(0, minLine - 6);
+      const ctxEnd = Math.min(newLinesAll.length, maxLine + 5);
+      const ctxLines = [];
+      const ctxHashes = [];
+      for (let i = ctxStart; i < ctxEnd; i++) {
+        const h = fnv1a(newLinesAll[i]);
+        ctxHashes.push(h);
+        ctxLines.push(`${lineTag(h)}.${i + 1}	${newLinesAll[i]}`);
+      }
+      const ctxCs = rangeChecksum(ctxHashes, ctxStart + 1, ctxEnd);
+      msg += `
+
+Post-edit (lines ${ctxStart + 1}-${ctxEnd}):
+${ctxLines.join("\n")}
+checksum: ${ctxCs}`;
+    }
+  }
+  return msg;
+}
+
+// lib/search.mjs
+import { spawn } from "node:child_process";
+import { resolve as resolve2 } from "node:path";
+var rgBin = "rg";
+try {
+  rgBin = (await import("@vscode/ripgrep")).rgPath;
+} catch {
+}
+var DEFAULT_LIMIT2 = 100;
+var MAX_OUTPUT = 10 * 1024 * 1024;
+var TIMEOUT2 = 3e4;
+function spawnRg(args) {
+  return new Promise((resolve_, reject) => {
+    let stdout = "";
+    let totalBytes = 0;
+    let killed = false;
+    let stderrBuf = "";
+    const child = spawn(rgBin, args, { timeout: TIMEOUT2 });
+    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 });
+    });
+  });
+}
+function grepSearch(pattern, opts = {}) {
+  const normPath = normalizePath(opts.path || "");
+  const target = normPath ? resolve2(normPath) : process.cwd();
+  const output = opts.output || "content";
+  const plain = !!opts.plain;
+  const totalLimit = opts.totalLimit && opts.totalLimit > 0 ? opts.totalLimit : 0;
+  if (output === "files") return filesMode(pattern, target, opts);
+  if (output === "count") return countMode(pattern, target, opts);
+  return contentMode(pattern, target, opts, plain, totalLimit);
+}
+async function filesMode(pattern, target, opts) {
+  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} \u2014 ${stderr.trim() || "unknown error"}`);
+  const lines = stdout.trimEnd().split("\n").filter(Boolean);
+  const normalized = lines.map((l) => l.replace(/\\/g, "/"));
+  return `\`\`\`
+${normalized.join("\n")}
+\`\`\``;
+}
+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} \u2014 ${stderr.trim() || "unknown error"}`);
+  const lines = stdout.trimEnd().split("\n").filter(Boolean);
+  const normalized = lines.map((l) => l.replace(/\\/g, "/"));
+  return `\`\`\`
+${normalized.join("\n")}
+\`\`\``;
+}
+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_LIMIT2;
+  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} \u2014 ${stderr.trim() || "unknown error"}`);
+  const jsonLines = stdout.trimEnd().split("\n").filter(Boolean);
+  const formatted = [];
+  const db = getGraphDB(target);
+  const relCache = /* @__PURE__ */ new Map();
+  let groupFile = null;
+  let groupLines = [];
+  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") {
+        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;
+    let content = data.lines?.text;
+    if (content === void 0 && data.lines?.bytes) {
+      content = Buffer.from(data.lines.bytes, "base64").toString("utf-8");
+    }
+    if (content === void 0) continue;
+    content = content.replace(/\n$/, "");
+    const subLines = content.split("\n");
+    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);
+      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 === void 0) {
+            rel = getRelativePath(resolve2(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}	${lineContent}${anno}`);
+      }
+    }
+    if (msg.type === "match") {
+      matchCount++;
+      if (totalLimit > 0 && matchCount >= totalLimit) {
+        flushGroup();
+        formatted.push(`--- total_limit reached (${totalLimit}) ---`);
+        return `\`\`\`
+${formatted.join("\n")}
+\`\`\``;
+      }
+    }
+  }
+  flushGroup();
+  return `\`\`\`
+${formatted.join("\n")}
+\`\`\``;
+}
+
+// lib/outline.mjs
+import { extname } from "node:path";
+
+// ../hex-common/src/parser/tree-sitter.mjs
+import { createRequire as createRequire2 } from "node:module";
+import { resolve as resolve3 } from "node:path";
+var parserInstance = null;
+var languageCache = /* @__PURE__ */ new Map();
+async function getParser() {
+  if (parserInstance) return parserInstance;
+  const { Parser } = await import("web-tree-sitter");
+  await Parser.init();
+  parserInstance = new Parser();
+  return parserInstance;
+}
+async function getLanguage(grammar) {
+  if (languageCache.has(grammar)) return languageCache.get(grammar);
+  await getParser();
+  const { Language } = await import("web-tree-sitter");
+  const require2 = createRequire2(import.meta.url);
+  const wasmPath = resolve3(
+    require2.resolve("tree-sitter-wasms/package.json"),
+    "..",
+    "out",
+    `tree-sitter-${grammar}.wasm`
+  );
+  const lang = await Language.load(wasmPath);
+  languageCache.set(grammar, lang);
+  return lang;
+}
+
+// ../hex-common/src/parser/languages.mjs
+var EXTENSION_GRAMMARS = {
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cs": "c_sharp",
+  ".rb": "ruby",
+  ".php": "php",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".sh": "bash",
+  ".bash": "bash"
+};
+function grammarForExtension(ext) {
+  return EXTENSION_GRAMMARS[ext.toLowerCase()] || null;
+}
+function supportedExtensions() {
+  return Object.keys(EXTENSION_GRAMMARS);
+}
+
+// ../hex-common/src/text/file-text.mjs
+import { readFileSync as readFileSync2 } from "node:fs";
+function normalizeSourceText(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function readUtf8Normalized(filePath) {
+  return normalizeSourceText(readFileSync2(filePath, "utf-8"));
+}
+
+// lib/outline.mjs
+var 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 };
+}
+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");
+}
+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}
+
+${formatOutline(result.entries, result.skippedRanges, content.split("\n").length, db, relFile)}`;
+}
+
+// lib/verify.mjs
+function verifyChecksums(filePath, checksums, opts = {}) {
+  filePath = normalizePath(filePath);
+  const real = validatePath(filePath);
+  const current = readSnapshot(real);
+  const baseSnapshot = opts.baseRevision ? getSnapshotByRevision(opts.baseRevision) : null;
+  const results = [];
+  let allValid = true;
+  for (const cs of checksums) {
+    const parsed = parseChecksum(cs);
+    if (parsed.start < 1 || parsed.end > current.lines.length) {
+      results.push(`${cs}: INVALID (range ${parsed.start}-${parsed.end} exceeds file length ${current.lines.length})`);
+      allValid = false;
+      continue;
+    }
+    const actual = buildRangeChecksum(current, parsed.start, parsed.end);
+    const currentHex = actual.split(":")[1];
+    if (currentHex === parsed.hex) {
+      results.push(`${cs}: valid`);
+    } else {
+      const staleBits = [`${cs}: STALE \u2192 current: ${actual}`];
+      if (baseSnapshot?.path === real) {
+        const changedRanges = computeChangedRanges(baseSnapshot.lines, current.lines);
+        staleBits.push(`revision: ${current.revision}`);
+        staleBits.push(`changed_ranges: ${describeChangedRanges(changedRanges)}`);
+      } else if (opts.baseRevision) {
+        staleBits.push(`revision: ${current.revision}`);
+        staleBits.push(`changed_ranges: unavailable (base revision evicted)`);
+      }
+      results.push(staleBits.join("\n"));
+      allValid = false;
+    }
+  }
+  if (allValid && checksums.length > 0) {
+    let msg = `All ${checksums.length} checksum(s) valid for ${filePath}`;
+    msg += `
+revision: ${current.revision}`;
+    msg += `
+file: ${current.fileChecksum}`;
+    return msg;
+  }
+  return results.join("\n");
+}
+
+// lib/tree.mjs
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync6, existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve4, basename, join as join4, relative as relative2 } from "node:path";
+import ignore from "ignore";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "__pycache__",
+  ".next",
+  "coverage"
+]);
+function globToRegex(pat) {
+  return new RegExp(
+    "^" + pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*").replace(/\?/g, ".") + "$"
+  );
+}
+function loadGitignore(rootDir) {
+  const gi = join4(rootDir, ".gitignore");
+  if (!existsSync3(gi)) return null;
+  try {
+    const content = readFileSync3(gi, "utf-8");
+    return ignore().add(content);
+  } catch {
+    return null;
+  }
+}
+function isIgnored(ig, relPath, isDir) {
+  if (!ig) return false;
+  return ig.ignores(isDir ? relPath + "/" : relPath);
+}
+function findByPattern(dirPath, opts) {
+  const re = globToRegex(opts.pattern);
+  const filterType = opts.type || "all";
+  const maxDepth = opts.max_depth ?? 20;
+  const abs = resolve4(normalizePath(dirPath));
+  if (!existsSync3(abs)) throw new Error(`DIRECTORY_NOT_FOUND: ${abs}`);
+  if (!statSync6(abs).isDirectory()) throw new Error(`Not a directory: ${abs}`);
+  const ig = opts.gitignore ?? true ? loadGitignore(abs) : null;
+  const matches = [];
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const isDir = entry.isDirectory();
+      if (SKIP_DIRS.has(entry.name) && isDir) continue;
+      const full = join4(dir, entry.name);
+      const rel = relative2(abs, full).replace(/\\/g, "/");
+      if (isIgnored(ig, rel, isDir)) continue;
+      if (re.test(entry.name)) {
+        if (filterType === "all" || filterType === "dir" && isDir || filterType === "file" && !isDir) {
+          matches.push(isDir ? rel + "/" : rel);
+        }
+      }
+      if (isDir) walk(full, depth + 1);
+    }
+  }
+  walk(abs, 1);
+  matches.sort();
+  const rootName = basename(abs);
+  if (matches.length === 0) {
+    return `No matches for "${opts.pattern}" in ${rootName}/`;
+  }
+  return `Found ${matches.length} match${matches.length === 1 ? "" : "es"} for "${opts.pattern}" in ${rootName}/
+
+${matches.join("\n")}`;
+}
+function directoryTree(dirPath, opts = {}) {
+  if (opts.pattern) return findByPattern(dirPath, opts);
+  const compact = opts.format === "compact";
+  const maxDepth = compact ? 1 : opts.max_depth ?? 3;
+  const abs = resolve4(normalizePath(dirPath));
+  if (!existsSync3(abs)) throw new Error(`DIRECTORY_NOT_FOUND: ${abs}. Check path or use directory_tree on parent directory.`);
+  const rootStat = statSync6(abs);
+  if (!rootStat.isDirectory()) throw new Error(`Not a directory: ${abs}`);
+  const ig = opts.gitignore ?? true ? loadGitignore(abs) : null;
+  let totalFiles = 0;
+  let totalSize = 0;
+  const lines = [];
+  function walk(dir, prefix, depth) {
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      return 0;
+    }
+    entries.sort((a, b) => {
+      const aDir = a.isDirectory() ? 0 : 1;
+      const bDir = b.isDirectory() ? 0 : 1;
+      if (aDir !== bDir) return aDir - bDir;
+      return a.name.localeCompare(b.name);
+    });
+    let subTotal = 0;
+    for (const entry of entries) {
+      const name = entry.name;
+      const isDir = entry.isDirectory();
+      if (SKIP_DIRS.has(name) && isDir) continue;
+      const full = join4(dir, name);
+      const rel = relative2(abs, full).replace(/\\/g, "/");
+      if (isIgnored(ig, rel, isDir)) continue;
+      if (isDir) {
+        if (compact) {
+          lines.push(`${prefix}${name}/`);
+        } else {
+          const lineIdx = lines.length;
+          lines.push("");
+          const count = depth < maxDepth ? walk(full, prefix + "  ", depth + 1) : countSubtreeFiles(full, ig, abs);
+          lines[lineIdx] = `${prefix}${name}/ (${count} files)`;
+          subTotal += count;
+        }
+        if (compact) walk(full, prefix + "  ", depth + 1);
+      } else {
+        totalFiles++;
+        subTotal++;
+        if (compact) {
+          lines.push(`${prefix}${name}`);
+        } else {
+          let size = 0, mtime = null, lineCount = null;
+          try {
+            const st = statSync6(full);
+            size = st.size;
+            mtime = st.mtime;
+          } catch {
+          }
+          totalSize += size;
+          lineCount = countFileLines(full, size);
+          const parts = [];
+          if (lineCount !== null) parts.push(`${lineCount}L`);
+          parts.push(formatSize(size));
+          if (mtime) parts.push(relativeTime(mtime, true));
+          lines.push(`${prefix}${name} (${parts.join(", ")})`);
+        }
+      }
+    }
+    return subTotal;
+  }
+  function countSubtreeFiles(dir, ig2, rootAbs, depth = 0) {
+    if (depth > 10) return 0;
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      return 0;
+    }
+    let count = 0;
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name) && entry.isDirectory()) continue;
+      const full = join4(dir, entry.name);
+      const rel = relative2(rootAbs, full).replace(/\\/g, "/");
+      if (isIgnored(ig2, rel, entry.isDirectory())) continue;
+      if (entry.isDirectory()) {
+        count += countSubtreeFiles(full, ig2, rootAbs, depth + 1);
+      } else {
+        count++;
+      }
+    }
+    return count;
+  }
+  const rootName = basename(abs);
+  walk(abs, "  ", 1);
+  const header = compact ? `Directory: ${rootName}/ (${totalFiles} files)` : `Directory: ${rootName}/ (${totalFiles} files, ${formatSize(totalSize)})`;
+  return `${header}
+
+${rootName}/
+${lines.join("\n")}`;
+}
+
+// lib/info.mjs
+import { statSync as statSync7, openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "node:fs";
+import { resolve as resolve5, isAbsolute as isAbsolute2, extname as extname2, basename as basename2 } from "node:path";
+var MAX_LINE_COUNT_SIZE = 10 * 1024 * 1024;
+var 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 = openSync2(filePath, "r");
+  const probe = Buffer.alloc(Math.min(size, 8192));
+  const bytesRead = readSync2(fd, probe, 0, probe.length, 0);
+  closeSync2(fd);
+  for (let i = 0; i < bytesRead; i++) {
+    if (probe[i] === 0) return true;
+  }
+  return false;
+}
+function fileInfo(filePath) {
+  if (!filePath) throw new Error("Empty file path");
+  const normalized = normalizePath(filePath);
+  const abs = isAbsolute2(normalized) ? normalized : resolve5(process.cwd(), normalized);
+  const stat = statSync7(abs);
+  if (!stat.isFile()) throw new Error(`Not a regular file: ${abs}`);
+  const size = stat.size;
+  const mtime = stat.mtime;
+  const ext = extname2(abs).toLowerCase();
+  const name = basename2(abs);
+  let typeName = EXT_NAMES[ext] || (ext ? `${ext.slice(1).toUpperCase()} file` : "Unknown type");
+  if (name === "Dockerfile") typeName = "Dockerfile";
+  if (name === "Makefile") typeName = "Makefile";
+  const isBinary = size > 0 ? detectBinary(abs, size) : false;
+  const lineCount = !isBinary && size > 0 ? countFileLines(abs, size, MAX_LINE_COUNT_SIZE) : null;
+  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");
+}
+
+// lib/setup.mjs
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync } from "node:fs";
+import { resolve as resolve6, dirname as dirname3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname3(__filename);
+var HOOK_SCRIPT = resolve6(__dirname, "..", "hook.mjs").replace(/\\/g, "/");
+var HOOK_COMMAND = `node ${HOOK_SCRIPT}`;
+var HOOK_SIGNATURE = "hex-line-mcp/hook.mjs";
+var NPX_MARKERS = ["_npx", "npx-cache", ".npm/_npx"];
+function isEphemeralInstall(scriptPath) {
+  return NPX_MARKERS.some((m) => scriptPath.includes(m));
+}
+var CLAUDE_HOOKS = {
+  SessionStart: {
+    matcher: "*",
+    hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }]
+  },
+  PreToolUse: {
+    matcher: "Read|Edit|Write|Grep|Bash|mcp__hex-line__.*",
+    hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 5 }]
+  },
+  PostToolUse: {
+    matcher: "Bash",
+    hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 10 }]
+  }
+};
+function readJson(filePath) {
+  if (!existsSync4(filePath)) return null;
+  return JSON.parse(readFileSync4(filePath, "utf-8"));
+}
+function writeJson(filePath, data) {
+  mkdirSync(dirname3(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function findEntryByCommand(entries) {
+  return entries.findIndex(
+    (e) => Array.isArray(e.hooks) && e.hooks.some(
+      (h) => typeof h.command === "string" && h.command.includes(HOOK_SIGNATURE)
+    )
+  );
+}
+function writeHooksToFile(settingsPath, label) {
+  const config = readJson(settingsPath) || {};
+  if (!config.hooks || typeof config.hooks !== "object") {
+    config.hooks = {};
+  }
+  let changed = false;
+  for (const [event, desired] of Object.entries(CLAUDE_HOOKS)) {
+    if (!Array.isArray(config.hooks[event])) {
+      config.hooks[event] = [];
+    }
+    const entries = config.hooks[event];
+    const idx = findEntryByCommand(entries);
+    if (idx >= 0) {
+      const existing = entries[idx];
+      if (existing.matcher === desired.matcher && existing.hooks.length === desired.hooks.length && existing.hooks[0].command === HOOK_COMMAND && existing.hooks[0].timeout === desired.hooks[0].timeout) {
+        continue;
+      }
+      entries[idx] = { matcher: desired.matcher, hooks: [...desired.hooks] };
+      changed = true;
+    } else {
+      entries.push({ matcher: desired.matcher, hooks: [...desired.hooks] });
+      changed = true;
+    }
+  }
+  if (config.disableAllHooks !== false) {
+    config.disableAllHooks = false;
+    changed = true;
+  }
+  if (!changed) {
+    return `Claude (${label}): already configured`;
+  }
+  writeJson(settingsPath, config);
+  return `Claude (${label}): hooks -> ${HOOK_SCRIPT} OK`;
+}
+function cleanLocalHooks() {
+  const localPath = resolve6(process.cwd(), ".claude/settings.local.json");
+  const config = readJson(localPath);
+  if (!config || !config.hooks || typeof config.hooks !== "object") {
+    return "local: clean";
+  }
+  let changed = false;
+  for (const event of Object.keys(CLAUDE_HOOKS)) {
+    if (!Array.isArray(config.hooks[event])) continue;
+    const entries = config.hooks[event];
+    const idx = findEntryByCommand(entries);
+    if (idx >= 0) {
+      entries.splice(idx, 1);
+      changed = true;
+    }
+    if (entries.length === 0) {
+      delete config.hooks[event];
+    }
+  }
+  if (Object.keys(config.hooks).length === 0) {
+    delete config.hooks;
+  }
+  if (!changed) {
+    return "local: clean";
+  }
+  writeJson(localPath, config);
+  return "local: removed old hex-line hooks";
+}
+function installOutputStyle() {
+  const source = resolve6(dirname3(fileURLToPath(import.meta.url)), "..", "output-style.md");
+  const target = resolve6(homedir(), ".claude", "output-styles", "hex-line.md");
+  mkdirSync(dirname3(target), { recursive: true });
+  writeFileSync2(target, readFileSync4(source, "utf-8"), "utf-8");
+  const userSettings = resolve6(homedir(), ".claude/settings.json");
+  const config = readJson(userSettings) || {};
+  const prev = config.outputStyle;
+  if (!prev) {
+    config.outputStyle = "hex-line";
+    writeJson(userSettings, config);
+  }
+  const msg = prev ? `Output style file installed. Existing style '${prev}' preserved (not overridden)` : "Output style 'hex-line' installed and activated globally";
+  return msg;
+}
+function setupClaude() {
+  if (isEphemeralInstall(HOOK_SCRIPT)) {
+    return "Claude: SKIPPED \u2014 hook.mjs is in npx cache (ephemeral). Install permanently: npm i -g @levnikolaevich/hex-line-mcp, then re-run setup_hooks.";
+  }
+  const results = [];
+  const globalPath = resolve6(homedir(), ".claude/settings.json");
+  results.push(writeHooksToFile(globalPath, "global"));
+  results.push(cleanLocalHooks());
+  results.push(installOutputStyle());
+  return results.join(" | ");
+}
+function setupGemini() {
+  return "Gemini: Not supported (Gemini CLI does not support hooks. Add MCP Tool Preferences to GEMINI.md instead)";
+}
+function setupCodex() {
+  return "Codex: Not supported (Codex CLI does not support hooks. Add MCP Tool Preferences to AGENTS.md instead)";
+}
+function uninstallClaude() {
+  const globalPath = resolve6(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";
+}
+var AGENTS = { claude: setupClaude, gemini: setupGemini, codex: setupCodex };
+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:
+  ${result}
+
+Restart Claude Code to apply changes.`;
+  }
+  if (target !== "all" && !AGENTS[target]) {
+    throw new Error(`UNKNOWN_AGENT: '${agent}'. Supported: claude, gemini, codex, all`);
+  }
+  const targets = target === "all" ? Object.keys(AGENTS) : [target];
+  const results = targets.map((name) => "  " + AGENTS[name]());
+  const header = `Hooks configured for ${target}:`;
+  const footer = "\nRestart Claude Code to apply hook changes.";
+  return [header, ...results, footer].join("\n");
+}
+
+// lib/changes.mjs
+import { execFileSync } from "node:child_process";
+import { statSync as statSync8 } from "node:fs";
+import { extname as extname3 } from "node:path";
+function symbolName(text) {
+  const clean = text.replace(/\s*\{?\s*$/, "").trim();
+  const noParams = clean.replace(/\(.*$/, "").trim();
+  const parts = noParams.split(/\s+/);
+  const eqIdx = parts.indexOf("=");
+  if (eqIdx > 0) return parts[eqIdx - 1];
+  return parts[parts.length - 1] || text;
+}
+function toSymbolMap(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const name = symbolName(e.text);
+    const lines = e.end - e.start + 1;
+    map.set(name, { name, text: e.text, lines, start: e.start, end: e.end });
+  }
+  return map;
+}
+function gitRelativePath(absPath) {
+  const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: absPath.replace(/[/\\][^/\\]+$/, ""),
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim().replace(/\\/g, "/");
+  const normalized = absPath.replace(/\\/g, "/");
+  const rootLower = root.toLowerCase();
+  const pathLower = normalized.toLowerCase();
+  if (!pathLower.startsWith(rootLower)) {
+    throw new Error(`File ${absPath} is not inside git repo ${root}`);
+  }
+  return normalized.slice(root.length + 1);
+}
+async function fileChanges(filePath, compareAgainst = "HEAD") {
+  filePath = normalizePath(filePath);
+  const real = validatePath(filePath);
+  if (statSync8(real).isDirectory()) {
+    try {
+      const stat = execFileSync("git", ["diff", "--stat", compareAgainst, "--", "."], {
+        cwd: real,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).trim();
+      if (!stat) return `No changes in ${filePath} vs ${compareAgainst}`;
+      return `Changed files in ${filePath} vs ${compareAgainst}:
+
+${stat}
+
+Use changes on a specific file for symbol-level diff.`;
+    } catch {
+      return `No git history for ${filePath} or not a git repository.`;
+    }
+  }
+  const ext = extname3(real).toLowerCase();
+  const currentContent = readText(real);
+  const currentResult = await outlineFromContent(currentContent, ext);
+  if (!currentResult) {
+    return `Cannot outline ${ext} files. Supported: .js .mjs .ts .py .go .rs .java .c .cpp .cs .rb .php .kt .swift .sh .bash`;
+  }
+  const relPath = gitRelativePath(real);
+  let gitContent;
+  try {
+    gitContent = execFileSync("git", ["show", `${compareAgainst}:${relPath}`], {
+      cwd: real.replace(/[/\\][^/\\]+$/, ""),
+      encoding: "utf-8",
+      timeout: 5e3
+    }).replace(/\r\n/g, "\n");
+  } catch {
+    return `NEW FILE: ${filePath} (not in ${compareAgainst})`;
+  }
+  const gitResult = await outlineFromContent(gitContent, ext);
+  if (!gitResult) {
+    return `Cannot outline git version of ${filePath}`;
+  }
+  const currentMap = toSymbolMap(currentResult.entries);
+  const gitMap = toSymbolMap(gitResult.entries);
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [name, sym] of currentMap) {
+    if (!gitMap.has(name)) {
+      added.push(sym);
+    } else {
+      const gitSym = gitMap.get(name);
+      if (gitSym.lines !== sym.lines) {
+        modified.push({ current: sym, git: gitSym });
+      }
+    }
+  }
+  for (const [name, sym] of gitMap) {
+    if (!currentMap.has(name)) {
+      removed.push(sym);
+    }
+  }
+  const parts = [`Changes in ${filePath} vs ${compareAgainst}:`];
+  if (added.length) {
+    parts.push("\nAdded:");
+    for (const s of added) parts.push(`  + ${s.start}-${s.end}: ${s.text}`);
+  }
+  if (removed.length) {
+    parts.push("\nRemoved:");
+    for (const s of removed) parts.push(`  - ${s.start}-${s.end}: ${s.text}`);
+  }
+  if (modified.length) {
+    parts.push("\nModified:");
+    for (const m of modified) {
+      const delta = m.current.lines - m.git.lines;
+      const sign = delta > 0 ? "+" : "";
+      parts.push(`  ~ ${m.current.start}-${m.current.end}: ${m.current.text}  (${sign}${delta} lines)`);
+    }
+  }
+  if (!added.length && !removed.length && !modified.length) {
+    parts.push("\nNo symbol changes detected.");
+  }
+  const summary = `${added.length} added, ${removed.length} removed, ${modified.length} modified`;
+  parts.push(`
+Summary: ${summary}`);
+  return parts.join("\n");
+}
+
+// lib/bulk-replace.mjs
+import { writeFileSync as writeFileSync3, readdirSync as readdirSync3 } from "node:fs";
+import { resolve as resolve7, relative as relative3, join as join5 } from "node:path";
+var ignoreMod;
+try {
+  ignoreMod = await import("ignore");
+} catch {
+}
+function walkFiles(dir, rootDir, ig) {
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const e of entries) {
+    if (e.name === ".git" || e.name === "node_modules") continue;
+    const full = join5(dir, e.name);
+    const rel = relative3(rootDir, full).replace(/\\/g, "/");
+    if (ig && ig.ignores(rel)) continue;
+    if (e.isDirectory()) {
+      results.push(...walkFiles(full, rootDir, ig));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function globMatch(filename, pattern) {
+  const re = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*").replace(/\?/g, ".");
+  return new RegExp("^" + re + "$").test(filename);
+}
+function loadGitignore2(rootDir) {
+  if (!ignoreMod) return null;
+  const ig = (ignoreMod.default || ignoreMod)();
+  try {
+    const content = readText(join5(rootDir, ".gitignore"));
+    ig.add(content);
+  } catch {
+  }
+  return ig;
+}
+function bulkReplace(rootDir, globPattern, replacements, opts = {}) {
+  const { dryRun = false, maxFiles = 100 } = opts;
+  const abs = resolve7(normalizePath(rootDir));
+  const ig = loadGitignore2(abs);
+  const allFiles = walkFiles(abs, abs, ig);
+  const files = allFiles.filter((f) => {
+    const rel = relative3(abs, f).replace(/\\/g, "/");
+    return globMatch(rel, globPattern);
+  });
+  if (files.length === 0) return "No files matched the glob pattern.";
+  if (files.length > maxFiles) {
+    return `TOO_MANY_FILES: Found ${files.length} files, max_files is ${maxFiles}. Use more specific glob or increase max_files.`;
+  }
+  const results = [];
+  let changed = 0, skipped = 0, errors = 0;
+  const MAX_OUTPUT2 = MAX_OUTPUT_CHARS;
+  let totalChars = 0;
+  for (const file of files) {
+    try {
+      const original = readText(file);
+      let content = original;
+      for (const { old: oldText, new: newText } of replacements) {
+        content = content.split(oldText).join(newText);
+      }
+      if (content === original) {
+        skipped++;
+        continue;
+      }
+      const diff = simpleDiff(original.split("\n"), content.split("\n"));
+      if (!dryRun) {
+        writeFileSync3(file, content, "utf-8");
+      }
+      const relPath = file.replace(abs, "").replace(/^[/\\]/, "");
+      results.push(`--- ${relPath}
+${diff || "(no visible diff)"}`);
+      changed++;
+      totalChars += results[results.length - 1].length;
+      if (totalChars > MAX_OUTPUT2) {
+        const remaining = files.length - files.indexOf(file) - 1;
+        if (remaining > 0) results.push(`OUTPUT_CAPPED: ${remaining} more files not shown. Output exceeded ${MAX_OUTPUT2} chars.`);
+        break;
+      }
+    } catch (e) {
+      results.push(`ERROR: ${file}: ${e.message}`);
+      errors++;
+    }
+  }
+  const header = `Bulk replace: ${changed} files changed, ${skipped} skipped, ${errors} errors (dry_run: ${dryRun})`;
+  return results.length ? `${header}
+
+${results.join("\n\n")}` : header;
+}
+
+// server.mjs
+var version = true ? "1.3.5" : (await null).createRequire(import.meta.url)("./package.json").version;
+var { server, StdioServerTransport } = await createServerRuntime({
+  name: "hex-line-mcp",
+  version,
+  installDir: "mcp/hex-line-mcp"
+});
+server.registerTool("read_file", {
+  title: "Read File",
+  description: "Read a file with hash-annotated lines, range checksums, and current revision. Use offset/limit for targeted reads; use outline first for large code files.",
+  inputSchema: z2.object({
+    path: z2.string().optional().describe("File or directory path"),
+    paths: z2.array(z2.string()).optional().describe("Array of file paths to read (batch mode)"),
+    offset: flexNum().describe("Start line (1-indexed, default: 1)"),
+    limit: flexNum().describe("Max lines (default: 2000, 0 = all)"),
+    plain: flexBool().describe("Omit hashes (lineNum|content)")
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p, paths: multi, offset, limit, plain } = coerceParams(rawParams);
+  try {
+    if (multi && multi.length > 0 && !p) {
+      const results = [];
+      for (const fp of multi) {
+        try {
+          results.push(readFile2(fp, { offset, limit, plain }));
+        } catch (e) {
+          results.push(`File: ${fp}
+
+ERROR: ${e.message}`);
+        }
+      }
+      return { content: [{ type: "text", text: results.join("\n\n---\n\n") }] };
+    }
+    if (!p) throw new Error("Either 'path' or 'paths' is required");
+    return { content: [{ type: "text", text: readFile2(p, { offset, limit, plain }) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("edit_file", {
+  title: "Edit File",
+  description: "Apply revision-aware partial edits to one file. Prefer one batched call per file. Supports set_line, replace_lines, insert_after, and replace_between. For text rename/refactor use bulk_replace.",
+  inputSchema: z2.object({
+    path: z2.string().describe("File to edit"),
+    edits: z2.string().describe(
+      'JSON array. Examples:\n{"set_line":{"anchor":"ab.12","new_text":"new"}} \u2014 replace line\n{"replace_lines":{"start_anchor":"ab.10","end_anchor":"cd.15","new_text":"...","range_checksum":"10-15:a1b2c3d4"}} \u2014 range\n{"replace_between":{"start_anchor":"ab.10","end_anchor":"cd.40","new_text":"...","boundary_mode":"inclusive"}} \u2014 block rewrite\n{"insert_after":{"anchor":"ab.20","text":"inserted"}} \u2014 insert below. For text rename use bulk_replace tool.'
+    ),
+    dry_run: flexBool().describe("Preview changes without writing"),
+    restore_indent: flexBool().describe("Auto-fix indentation to match anchor (default: false)"),
+    base_revision: z2.string().optional().describe("Prior revision from read_file/edit_file. Enables conservative auto-rebase for same-file follow-up edits."),
+    conflict_policy: z2.enum(["strict", "conservative"]).optional().describe('Conflict handling (default: "conservative"). "conservative" returns structured CONFLICT output for stale edits instead of forcing reread.')
+  }),
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+}, async (rawParams) => {
+  const { path: p, edits: json, dry_run, restore_indent, base_revision, conflict_policy } = coerceParams(rawParams);
+  try {
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || !parsed.length) throw new Error("Edits: non-empty JSON array required");
+    return {
+      content: [{
+        type: "text",
+        text: editFile(p, parsed, {
+          dryRun: dry_run,
+          restoreIndent: restore_indent,
+          baseRevision: base_revision,
+          conflictPolicy: conflict_policy
+        })
+      }]
+    };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("write_file", {
+  title: "Write File",
+  description: "Create a new file or overwrite existing. Creates parent dirs. For existing files prefer edit_file (shows diff, verifies hashes).",
+  inputSchema: z2.object({
+    path: z2.string().describe("File path"),
+    content: z2.string().describe("File content")
+  }),
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p, content } = coerceParams(rawParams);
+  try {
+    const abs = validateWritePath(p);
+    mkdirSync2(dirname4(abs), { recursive: true });
+    writeFileSync4(abs, content, "utf-8");
+    return { content: [{ type: "text", text: `Created ${p} (${content.split("\n").length} lines)` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("grep_search", {
+  title: "Search Files",
+  description: "Search file contents with ripgrep. Returns hash-annotated matches with per-group checksums for direct editing. Output modes: content (default, edit-ready hashes+checksums), files (paths only), count (match counts). For single-line edits: grep -> set_line directly. For range edits: use checksum from grep output. ALWAYS prefer over shell grep/rg/findstr.",
+  inputSchema: z2.object({
+    pattern: z2.string().describe("Search pattern (regex by default, literal if literal:true)"),
+    path: z2.string().optional().describe("Search dir/file (default: cwd)"),
+    glob: z2.string().optional().describe('Glob filter (e.g. "*.ts")'),
+    type: z2.string().optional().describe('File type (e.g. "js", "py")'),
+    output: z2.enum(["content", "files", "count"]).optional().describe("Output format (default: content)"),
+    case_insensitive: flexBool().describe("Ignore case (-i)"),
+    smart_case: flexBool().describe("CI when pattern is all lowercase, CS if uppercase (-S)"),
+    literal: flexBool().describe("Literal string search, no regex (-F)"),
+    multiline: flexBool().describe("Pattern can span multiple lines (-U)"),
+    context: flexNum().describe("Symmetric context lines around matches (-C)"),
+    context_before: flexNum().describe("Context lines BEFORE match (-B)"),
+    context_after: flexNum().describe("Context lines AFTER match (-A)"),
+    limit: flexNum().describe("Max matches per file (default: 100)"),
+    total_limit: flexNum().describe("Total match events across all files; multiline matches count as 1 (0 = unlimited)"),
+    plain: flexBool().describe("Omit hash tags, return file:line:content")
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const {
+    pattern,
+    path: p,
+    glob,
+    type,
+    output,
+    case_insensitive,
+    smart_case,
+    literal,
+    multiline,
+    context,
+    context_before,
+    context_after,
+    limit,
+    total_limit,
+    plain
+  } = coerceParams(rawParams);
+  try {
+    const result = await grepSearch(pattern, {
+      path: p,
+      glob,
+      type,
+      output,
+      caseInsensitive: case_insensitive,
+      smartCase: smart_case,
+      literal,
+      multiline,
+      context,
+      contextBefore: context_before,
+      contextAfter: context_after,
+      limit,
+      totalLimit: total_limit,
+      plain
+    });
+    return { content: [{ type: "text", text: result }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("outline", {
+  title: "File Outline",
+  description: "AST-based structural outline: functions, classes, interfaces with line ranges. 10-20 lines instead of 500 \u2014 95% token reduction. Use before reading large code files. NOT for .md/.json/.yaml \u2014 use read_file.",
+  inputSchema: z2.object({
+    path: z2.string().describe("Source file path")
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p } = coerceParams(rawParams);
+  try {
+    const result = await fileOutline(p);
+    return { content: [{ type: "text", text: result }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("verify", {
+  title: "Verify Checksums",
+  description: "Check whether held checksums and optional base_revision are still current, without rereading the file.",
+  inputSchema: z2.object({
+    path: z2.string().describe("File path"),
+    checksums: z2.string().describe('JSON array of checksum strings, e.g. ["1-50:f7e2a1b0", "51-100:abcd1234"]'),
+    base_revision: z2.string().optional().describe("Optional prior revision to compare against latest state.")
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p, checksums, base_revision } = coerceParams(rawParams);
+  try {
+    const parsed = JSON.parse(checksums);
+    if (!Array.isArray(parsed)) throw new Error("checksums must be a JSON array of strings");
+    return { content: [{ type: "text", text: verifyChecksums(p, parsed, { baseRevision: base_revision }) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("directory_tree", {
+  title: "Directory Tree",
+  description: "Compact directory tree with root .gitignore support (path-based rules, negation). Supports pattern glob to find files/dirs by name (like find -name). Use to understand repo structure or find specific files/dirs. Skips node_modules, .git, dist by default.",
+  inputSchema: z2.object({
+    path: z2.string().describe("Directory path"),
+    pattern: z2.string().optional().describe('Glob filter on names (e.g. "*-mcp", "*.mjs"). Returns flat match list instead of tree'),
+    type: z2.enum(["file", "dir", "all"]).optional().describe('"file", "dir", or "all" (default). Like find -type f/d'),
+    max_depth: flexNum().describe("Max recursion depth (default: 3, or 20 in pattern mode)"),
+    gitignore: flexBool().describe("Respect root .gitignore patterns (default: true). Nested .gitignore not supported"),
+    format: z2.enum(["compact", "full"]).optional().describe('"compact" = names only, no sizes, depth 1. "full" = default with sizes')
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p, max_depth, gitignore, format, pattern, type: entryType } = coerceParams(rawParams);
+  try {
+    return { content: [{ type: "text", text: directoryTree(p, { max_depth, gitignore, format, pattern, type: entryType }) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("get_file_info", {
+  title: "File Info",
+  description: "File metadata without reading content: size, line count, modification time, type, binary detection. Use before reading large files to check size.",
+  inputSchema: z2.object({
+    path: z2.string().describe("File path")
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p } = coerceParams(rawParams);
+  try {
+    return { content: [{ type: "text", text: fileInfo(p) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("setup_hooks", {
+  title: "Setup Hooks",
+  description: "Install or uninstall hex-line hooks in CLI agent settings. install: writes hooks to ~/.claude/settings.json, removes old per-project hooks. uninstall: removes hex-line hooks from global settings. Idempotent: re-running produces no changes if already in desired state.",
+  inputSchema: z2.object({
+    agent: z2.string().optional().describe('Target agent: "claude", "gemini", "codex", or "all" (default: "all")'),
+    action: z2.string().optional().describe('"install" (default) or "uninstall"')
+  }),
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { agent, action } = coerceParams(rawParams);
+  try {
+    return { content: [{ type: "text", text: setupHooks(agent, action) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("changes", {
+  title: "Semantic Diff",
+  description: "Compare file or directory against git ref (default: HEAD). For files: shows added/removed/modified symbols at AST level. For directories: lists changed files with insertions/deletions stats. Use to understand what changed before committing.",
+  inputSchema: z2.object({
+    path: z2.string().describe("File or directory path"),
+    compare_against: z2.string().optional().describe('Git ref to compare against (default: "HEAD")')
+  }),
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+}, async (rawParams) => {
+  const { path: p, compare_against } = coerceParams(rawParams);
+  try {
+    return { content: [{ type: "text", text: await fileChanges(p, compare_against) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+server.registerTool("bulk_replace", {
+  title: "Bulk Replace",
+  description: "Search-and-replace across multiple files. Finds files by glob, applies ordered text replacements, returns per-file diffs. Use dry_run:true to preview. For single-file rename, set glob to the filename.",
+  inputSchema: z2.object({
+    replacements: z2.string().describe('JSON array of {old, new} pairs: [{"old":"foo","new":"bar"}]'),
+    glob: z2.string().optional().describe('File glob (default: "**/*.{md,mjs,json,yml,ts,js}")'),
+    path: z2.string().optional().describe("Root directory (default: cwd)"),
+    dry_run: flexBool().describe("Preview without writing (default: false)"),
+    max_files: flexNum().describe("Max files to process (default: 100)")
+  }),
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
+}, async (rawParams) => {
+  try {
+    const params = coerceParams(rawParams);
+    const replacements = JSON.parse(params.replacements);
+    if (!Array.isArray(replacements) || !replacements.length) throw new Error("replacements: non-empty JSON array of {old, new} required");
+    const result = bulkReplace(
+      params.path || process.cwd(),
+      params.glob || "**/*.{md,mjs,json,yml,ts,js}",
+      replacements,
+      { dryRun: params.dry_run || false, maxFiles: params.max_files || 100 }
+    );
+    return { content: [{ type: "text", text: result }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: e.message }], isError: true };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);
+void checkForUpdates("@levnikolaevich/hex-line-mcp", version);