release: @levnikolaevich/hex-line-mcp v1.27.1

- lib/search.mjs: handle CRLF ripgrep output on Windows (split on /\r?\n/) so summary mode counts files correctly
- scenarios: generic-external-repo fallback workflow suite (W1 outline-read, W2 summary-to-edit-ready, W3 verified dry-run edit)
- README + output-style.md: audit_workspace bounded-output guidance
- test/smoke.mjs: CRLF summary-mode regression guard

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: levnikolaevich

mcp/hex-line-mcp/README.md

@@ -106,6 +106,8 @@ The diagnostics run reports graph payload overhead and auto-refresh telemetry. R
 
 Comparative built-in vs hex-line benchmarks are maintained outside this package. External-baseline comparisons must reuse the same scenario suite and correctness contract before making broader claims.
 
+When `--repo` points at a repository outside `hex-line-mcp`, the scenario runner uses a generic external-repo suite instead of package-specific fixtures. The report labels the mode explicitly.
+
 ### Optional Graph Enrichment
 
 If a project already has `.hex-skills/codegraph/index.db`, `hex-line` automatically adds lightweight graph hints to `read_file`, `outline`, `grep_search`, `edit_file`, and `changes`.
@@ -289,7 +291,7 @@ Search file contents using ripgrep. Default mode is `summary` for discovery. Use
 | `edit_ready` | boolean | no | Preserve hash/checksum search hunks in `content` mode |
 | `allow_large_output` | boolean | no | Bypass the default `content`-mode block/char caps when you intentionally need a larger payload |
 
-`summary` mode returns counts, top files, and a few plain snippets. `content` mode returns canonical `search_hunk` blocks with per-hunk checksums enabling direct `replace_lines` from grep results without intermediate `read_file`.
+`summary` mode returns counts and top files without canonical hunks. `content` mode returns canonical `search_hunk` blocks with per-hunk checksums enabling direct `replace_lines` from grep results without intermediate `read_file`.
 
 - Default `content` mode is intentionally capped to keep discovery cheap. When truncation happens, the diagnostic block includes `shown_matches`, `file_count`, `truncated`, `next_action`, and `suggested_refine_call`.
 - Treat `allow_large_output: true` as an explicit override for review/debug workflows, not as the normal discovery path.

mcp/hex-line-mcp/lib/search.mjs

@@ -183,7 +183,7 @@ async function summaryMode(pattern, target, opts, totalLimit) {
     if (code === 1) return "No matches found.";
     if (code !== 0 && code !== null) throw new Error(`GREP_ERROR: rg exit ${code} — ${stderr.trim() || "unknown error"}`);
 
-    const rawLines = stdout.trimEnd().split("\n").filter(Boolean);
+    const rawLines = stdout.trimEnd().split(/\r?\n/).filter(Boolean);
     const visible = totalLimit > 0 ? rawLines.slice(0, totalLimit) : rawLines;
     const fileHits = new Map();
     const snippets = [];

mcp/hex-line-mcp/output-style.md

@@ -72,6 +72,7 @@ Use `hex-graph` only for semantic code questions:
 - `find_references` and `trace_paths` for usage and blast radius
 - `analyze_changes`, `audit_workspace`, and `analyze_architecture` for review and audit work
 - Always include `path` for `hex-graph` queries, using the active project root by default.
+- For `audit_workspace`, start bounded: `verbosity="minimal"`, add `scope` when known, and increase `limit` or `clone_member_limit` only for intentional deeper review.
 
 # Response Style
 

mcp/hex-line-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levnikolaevich/hex-line-mcp",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "mcpName": "io.github.levnikolaevich/hex-line-mcp",
   "type": "module",
   "description": "Hash-verified file editing MCP + token efficiency hook for AI coding agents. 9 tools: inspect_path, read, edit, write, grep, outline, verify, changes, bulk_replace.",

mcp/hex-line-mcp/scenarios/index.mjs

@@ -68,6 +68,9 @@ async function main() {
 
     // Build config shared across all benchmark modules
     const config = { allFiles, cats, largeFiles, tmpPath, tmpContent, tmpLines, repoRoot, ts };
+    const workflowMode = getFileLines(resolve(repoRoot, "hook.mjs")) && getFileLines(resolve(repoRoot, "lib", "setup.mjs"))
+        ? "self-fixture"
+        : "generic external repo";
 
     // Run benchmark suites
     const workflowResults = await runWorkflows(config);
@@ -88,7 +91,7 @@ async function main() {
     out.push(`Date: ${new Date().toISOString().slice(0, 10)}  `);
     out.push(`Runs per scenario: ${RUNS} (median)  `);
     out.push("");
-    out.push("Mode: hex-line workflow benchmark");
+    out.push(`Mode: hex-line workflow benchmark (${workflowMode})`);
     out.push("");
     out.push("## Workflow Scenarios");
     out.push("");

mcp/hex-line-mcp/scenarios/workflows.mjs

@@ -21,6 +21,7 @@ import { verifyChecksums } from "../lib/verify.mjs";
 import { editFile } from "../lib/edit.mjs";
 import { bulkReplace } from "../lib/bulk-replace.mjs";
 import { fileOutline } from "../lib/outline.mjs";
+import { grepSearch } from "../lib/search.mjs";
 import { getFileLines, runN } from "../lib/scenario-helpers.mjs";
 
 function ensureLine(lines, matcher, label) {
@@ -37,9 +38,113 @@ function copyIntoTemp(tempRoot, sourceRoot, relPath) {
     return dst;
 }
 
+function selectGenericFile(allFiles, largeFiles) {
+    return [...largeFiles, ...allFiles].find((file) => {
+        const lines = getFileLines(file);
+        return lines && lines.length >= 10;
+    });
+}
+
+function selectGenericPattern(lines) {
+    const joined = lines.join("\n");
+    for (const pattern of ["function", "class", "async", "import", "def", "export", "const"]) {
+        if (joined.includes(pattern)) return pattern;
+    }
+    const line = lines.find((entry) => /\w{4,}/.test(entry)) || "";
+    return line.match(/\w{4,}/)?.[0] || "TODO";
+}
+
+async function runGenericExternalWorkflows(config) {
+    const { repoRoot, allFiles, largeFiles, ts } = config;
+    const workflowResults = [];
+    const sourcePath = selectGenericFile(allFiles, largeFiles);
+    const sourceLines = sourcePath ? getFileLines(sourcePath) : null;
+    if (!sourcePath || !sourceLines) return workflowResults;
+
+    // W1: outline + targeted read on a real large file.
+    {
+        let chars = 0;
+        chars += (await fileOutline(sourcePath)).length;
+        chars += readFile(sourcePath, { offset: 1, limit: Math.min(80, sourceLines.length) }).length;
+        workflowResults.push({
+            id: "W1",
+            scenario: "External repo structure-first large-file read",
+            chars,
+            ops: 2,
+        });
+    }
+
+    // W2: summary-first search, then edit-ready hunks only for a narrowed file.
+    {
+        const pattern = selectGenericPattern(sourceLines);
+        let chars = 0;
+        chars += (await grepSearch(pattern, {
+            path: repoRoot,
+            output: "summary",
+            totalLimit: 50,
+            limit: 10,
+        })).length;
+        chars += (await grepSearch(pattern, {
+            path: sourcePath,
+            output: "content",
+            editReady: true,
+            totalLimit: 20,
+            limit: 5,
+        })).length;
+        workflowResults.push({
+            id: "W2",
+            scenario: "External repo search summary to edit-ready hunks",
+            chars,
+            ops: 2,
+        });
+    }
+
+    // W3: verified dry-run edit on a temp copy so external repos stay untouched.
+    {
+        const targetIdx = sourceLines.findIndex((line) => line.trim() && !line.trim().startsWith("//"));
+        if (targetIdx !== -1) {
+            const tempPath = resolve(tmpdir(), `hex-line-external-wf3-${ts}.tmp`);
+            copyFileSync(sourcePath, tempPath);
+            const start = Math.max(1, targetIdx + 1 - 2);
+            const end = Math.min(sourceLines.length, targetIdx + 1 + 2);
+            const hashes = sourceLines.slice(start - 1, end).map((line) => fnv1a(line));
+            const checksum = rangeChecksum(hashes, start, end);
+            const tag = lineTag(fnv1a(sourceLines[targetIdx]));
+            const updatedLine = `${sourceLines[targetIdx]} `;
+            const { value: chars } = runN(() => {
+                let total = 0;
+                total += readFile(tempPath, { offset: start, limit: end - start + 1, editReady: true, verbosity: "full" }).length;
+                try {
+                    total += editFile(tempPath, [{ set_line: { anchor: `${tag}.${targetIdx + 1}`, new_text: updatedLine } }], { dryRun: true }).length;
+                } catch (e) {
+                    total += e.message.length;
+                }
+                try {
+                    total += verifyChecksums(tempPath, [checksum]).length;
+                } catch (e) {
+                    total += e.message.length;
+                }
+                return total;
+            });
+            workflowResults.push({
+                id: "W3",
+                scenario: "External repo verified dry-run edit on temp copy",
+                chars,
+                ops: 3,
+            });
+            try { unlinkSync(tempPath); } catch {}
+        }
+    }
+
+    return workflowResults;
+}
+
 export async function runWorkflows(config) {
     const { repoRoot, allFiles, largeFiles } = config;
     const workflowResults = [];
+    if (!getFileLines(resolve(repoRoot, "hook.mjs")) || !getFileLines(resolve(repoRoot, "lib", "setup.mjs"))) {
+        return runGenericExternalWorkflows(config);
+    }
 
     // W1: grep tag + editFile (debug hex-line hook formatting)
     {

mcp/hex-line-mcp/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/levnikolaevich/claude-code-skills",
     "source": "github"
   },
-  "version": "1.27.0",
+  "version": "1.27.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@levnikolaevich/hex-line-mcp",
-      "version": "1.27.0",
+      "version": "1.27.1",
       "transport": {
         "type": "stdio"
       }

mcp/hex-line-mcp/test/smoke.mjs

@@ -1335,6 +1335,26 @@ describe("grep_search output modes", () => {
         assert.ok(!result.includes("block: search_hunk"), "summary mode omits canonical hunks");
     });
 
+    it("summary mode counts files for Windows ripgrep CRLF output", async () => {
+        const { grepSearch } = await import("../lib/search.mjs");
+        const dir = makeTempRepo("hex-test-grep-summary-crlf-", {
+            "src/one.ts": "export function alpha() { return 1; }\n",
+            "src/two.ts": "export function beta() { return 2; }\n",
+        });
+        try {
+            const result = await grepSearch("export function", {
+                path: dir,
+                output: "summary",
+                limit: 20,
+                totalLimit: 20,
+            });
+            assert.match(result, /summary: 2 match event\(s\) across 2 file\(s\)/);
+            assert.ok(result.includes("top_files:"), `summary should include top files: ${result}`);
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+
     it("files mode returns only paths, count mode returns counts", async () => {
         const { grepSearch } = await import("../lib/search.mjs");
         const files = await grepSearch("export", { path: CWD + "/lib", output: "files" });