@davesheffer/hunch 1.41.5 → 1.41.6

package/dist/core/docanchors.js

@@ -1,4 +1,5 @@
 import { currentForTopic, rejectedForTopic } from "./topics.js";
+import { normalizeEol } from "./eol.js";
 const MARKER = /<!--\s*hunch:topic\s+([A-Za-z0-9._/-]+)(?:\s+(dec_[A-Za-z0-9]+))?\s*-->/g;
 /** Expand the leading whitespace of a line to columns. A tab advances to the
  *  NEXT 4-column tab stop (CommonMark), not a flat 4 columns: after two
@@ -238,7 +239,7 @@ export function parseDocAnchors(text) {
     // a live, pinned anchor. Normalizing both CRLF and lone CR once here keeps
     // fencedRanges/inlineSpanRanges/MARKER offsets consistent with each other
     // and with the line numbers reported below.
-    text = text.replace(/\r\n?/g, "\n");
+    text = normalizeEol(text);
     const out = [];
     const skip = [...fencedRanges(text), ...inlineSpanRanges(text)];
     MARKER.lastIndex = 0;

package/dist/core/eol.d.ts

@@ -0,0 +1,10 @@
+/** Canonical line endings for parsers that do not expose source offsets. */
+export declare function normalizeEol(text: string): string;
+/** Remove the CR retained by split("\n") without changing source offsets. */
+export declare function lineContent(line: string): string;
+/** Read logical lines while keeping offsets in the original UTF-16 source. */
+export declare function sourceLines(text: string): Generator<{
+    content: string;
+    start: number;
+    end: number;
+}>;

package/dist/core/eol.js

@@ -0,0 +1,23 @@
+/** Canonical line endings for parsers that do not expose source offsets. */
+export function normalizeEol(text) {
+    return text.replace(/\r\n?|\n/g, "\n");
+}
+/** Remove the CR retained by split("\n") without changing source offsets. */
+export function lineContent(line) {
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+/** Read logical lines while keeping offsets in the original UTF-16 source. */
+export function* sourceLines(text) {
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== "\r" && text[i] !== "\n")
+            continue;
+        const end = i;
+        if (text[i] === "\r" && text[i + 1] === "\n")
+            i++;
+        yield { content: text.slice(start, end), start, end };
+        start = i + 1;
+    }
+    yield { content: text.slice(start), start, end: text.length };
+}
+//# sourceMappingURL=eol.js.map

package/dist/core/groundingMerge.js

@@ -20,15 +20,15 @@
  */
 import { execFileSync } from "node:child_process";
 import { parseGroundingCounts, stripCountsMatch, renderCountsMatch } from "./groundingLag.js";
-// `\r?\n` (not a bare `\n`) throughout: on a CRLF worktree every diff3 marker
-// line is itself `\r\n`-terminated, and a bare `\n` fails to match ANY of
-// them. `^...$` with /m anchor each marker at its own line start rather than
+import { normalizeEol } from "./eol.js";
+// The entry point normalizes EOL before matching. `^...$` with /m anchors
+// each marker at its own line start rather than
 // requiring a specific preceding/following literal newline, so a hunk whose
 // ours or theirs side is EMPTY (one side deleted the line, the other edited
 // it) still matches — with a literal `\n` requirement there, git's real
 // output for that shape has no such newline to match, so the whole hunk
 // silently fails to match at all.
-const CONFLICT_RE = /^<<<<<<< ours\r?\n([\s\S]*?)^\|\|\|\|\|\|\| base\r?\n[\s\S]*?^=======\r?\n([\s\S]*?)^>>>>>>> theirs[^\n]*\r?\n?/gm;
+const CONFLICT_RE = /^<<<<<<< ours\n([\s\S]*?)^\|\|\|\|\|\|\| base\n[\s\S]*?^=======\n([\s\S]*?)^>>>>>>> theirs[^\n]*\n?/gm;
 /** `null` when the hunk isn't confined to the counts sentence; otherwise the
  *  resolved sentence text, with each field taken as max(ours, theirs). */
 function resolveCountsOnlyHunk(ours, theirs) {
@@ -52,8 +52,10 @@ function resolveCountsOnlyHunk(ours, theirs) {
 export function resolveGroundingConflicts(diff3Text) {
     if (!diff3Text.includes("<<<<<<< ours"))
         return { conflict: false, text: diff3Text };
+    const eol = diff3Text.includes("\r\n") ? "\r\n" : diff3Text.includes("\r") ? "\r" : "\n";
+    const normalized = normalizeEol(diff3Text);
     let allResolved = true;
-    const resolved = diff3Text.replace(CONFLICT_RE, (whole, ours, theirs) => {
+    const resolved = normalized.replace(CONFLICT_RE, (whole, ours, theirs) => {
         const merged = resolveCountsOnlyHunk(ours, theirs);
         if (merged === null) {
             allResolved = false;
@@ -66,7 +68,7 @@ export function resolveGroundingConflicts(diff3Text) {
     // marker survives, this is a real conflict, full stop.
     if (!allResolved || resolved.includes("<<<<<<< ours"))
         return { conflict: true, text: diff3Text };
-    return { conflict: false, text: resolved };
+    return { conflict: false, text: eol === "\n" ? resolved : resolved.replace(/\n/g, eol) };
 }
 /** Run `git merge-file --diff3` on real files and resolve the result.
  *  `write: null` means git itself errored (e.g. one side is binary) — never

package/dist/extractors/k8sManifest.js

@@ -1,25 +1,4 @@
-/**
- * Deterministic text scan for Kubernetes manifest cross-resource references —
- * NOT a tree-sitter walk. Confirmed directly (not assumed): parsing a realistic
- * templated Deployment with this repo's own tree-sitter-yaml bundle showed a
- * same-line templated scalar (`name: {{ include "x" . }}`) parses cleanly, but
- * a block-form injection on its own line (`labels:\n  {{- include ... }}` — the
- * pattern real charts use for metadata.labels and spec.selector) collapses the
- * WHOLE REST OF THE DOCUMENT'S error recovery into a flat, unstructured ERROR
- * node. Real charts place such an injection early (right after metadata.name),
- * so it would poison parsing for every field-path this module needs further
- * down the same document. parseSource() (parse.ts) also never exposes its
- * tree-sitter tree to callers at all -- helm.ts's own text-scan precedent
- * exists for the same reason.
- *
- * This is a line-oriented, indentation-tracking scanner (not flat regex, unlike
- * helm.ts's `{{ }}`-action scan) because K8s field-paths are nested block
- * structure (`spec.template.spec.containers[].env[].valueFrom.secretKeyRef.name`)
- * that a flat scan can't reconstruct. It never interprets `{{ }}` as YAML syntax
- * at all -- a `{{ ... }}` on a line's value side is just that line's raw value
- * text, same-line or block-form alike -- so it is immune to the exact failure
- * mode that broke tree-sitter.
- */
+import { sourceLines } from "../core/eol.js";
 // ReplicaSet is included alongside the pod-spec-embedding/networking kinds
 // specifically because it's the dominant real-world bearer of
 // ownerReferences (Deployment -> ReplicaSet -> Pod is the common chain) --
@@ -42,14 +21,9 @@ function wildcardPath(path) {
 function framePath(frames) {
     return frames.map((f) => f.key).filter(Boolean).join(".").replace(/\.\[/g, "[");
 }
-// `\r?` before `$`: without it, a CRLF-terminated line (the Git-for-Windows
-// `core.autocrlf=true` default -- every .yaml file in a Windows checkout) never
-// matches at all, since JS `.` never matches `\r` and `$` (no /m flag) only
-// matches at the true end of the string. That silently zeroes out this whole
-// module's output on any Windows clone, with no error. `.*?` (lazy, not `.*`
-// greedy) so `\r?` gets first claim on a trailing `\r` instead of the value
-// capture swallowing it.
-const KEY_LINE = /^(\s*)(-\s+)?([A-Za-z0-9_.\/-]+):[ \t]*(.*?)\r?$/;
+// sourceLines removes line terminators while retaining offsets in the original
+// source, so every line parser sees the same content on LF, CRLF, and CR input.
+const KEY_LINE = /^(\s*)(-\s+)?([A-Za-z0-9_.\/-]+):[ \t]*(.*?)$/;
 // A line that is ENTIRELY a `{{ ... }}` template action (no `key:` prefix at
 // all) -- e.g. a block-form injection appearing as a SIBLING after other
 // literal keys under the same mapping (`app: my-app` then, on its own later
@@ -70,7 +44,7 @@ const BARE_TEMPLATE_LINE = /^\s*(?:-\s+)?\{\{[\s\S]*$/;
 // branch, which used ORDINARY popping and lost the list-item frame entirely
 // -- reparenting the item's real children one level up (`containers.name`
 // instead of `containers[0].name`), silently dropping every reference under it.
-const BARE_LIST_MARKER = /^(\s*)-[ \t]*\r?$/;
+const BARE_LIST_MARKER = /^(\s*)-[ \t]*$/;
 // A list item whose ENTIRE content is a block-scalar header (`- |`, `- |-`,
 // `- >`, `- |2`, `- | # comment`) -- the idiomatic way a chart inlines a shell
 // script into `args:`/`command:`. The item's value is opaque TEXT, not YAML,
@@ -84,7 +58,7 @@ const BARE_LIST_MARKER = /^(\s*)-[ \t]*\r?$/;
 // match. The rest is captured (not `[|>]` inline) so the header can be run
 // through stripTrailingComment before BLOCK_SCALAR_HEADER, exactly as a
 // key line's value is.
-const BLOCK_SCALAR_LIST_ITEM = /^(\s*)-[ \t]+(.*?)\r?$/;
+const BLOCK_SCALAR_LIST_ITEM = /^(\s*)-[ \t]+(.*?)$/;
 // A YAML block-scalar header (`|`, `>`, plus an optional chomping indicator
 // `+`/`-` and/or an explicit indent digit, in either order: `|`, `|-`, `>+`,
 // `|2`, `|2-`, `|-2`). When a key's value is JUST this header, the real
@@ -161,7 +135,6 @@ function scanFieldPaths(text, baseChar) {
     // (selector/labels) cares, and it checks this set itself.
     const valuelessKeyParents = new Set();
     const stack = [];
-    let charOffset = baseChar;
     // Indent of the `-` of a `- |` list item whose block-scalar body is being
     // skipped, or null when no such skip is active. The body ends at the first
     // line indented at or shallower than that dash (YAML's own rule for where a
@@ -229,13 +202,11 @@ function scanFieldPaths(text, baseChar) {
             unresolvedContainers.add(framePath(stack.slice(0, depth)));
         }
     };
-    for (const line of text.split("\n")) {
-        const lineStartChar = charOffset;
-        charOffset += line.length + 1; // +1 for the \n split() consumed
+    for (const { content: line, start } of sourceLines(text)) {
+        const lineStartChar = baseChar + start;
         // Inside a `- |` item's body: these lines are script/config TEXT, so they
-        // must never be read as field structure. Runs after the charOffset
-        // bookkeeping above so skipped lines still advance the offset exactly --
-        // every atChar/endChar after the block scalar depends on it.
+        // must never be read as field structure. sourceLines retains original
+        // offsets even when skipped lines use CRLF.
         if (blockScalarSkipIndent !== null) {
             // A blank line is part of the block scalar (YAML lets a scalar body
             // contain empty lines at any indent), never its terminator.
@@ -671,12 +642,14 @@ function buildDocument(text, docStartChar, entries, unresolvedContainers, valuel
 // deliberately NOT a separator -- real YAML doesn't treat it as one either,
 // and it still isn't here: the dashes must be followed by whitespace or end
 // of line.
-const DOC_SEPARATOR = /^(?:---(?:[ \t]+.*)?|\.\.\.)[ \t]*\r?$/m;
+const DOC_SEPARATOR = /^(?:---(?:[ \t]+.*)?|\.\.\.)[ \t]*$/;
 export function extractK8sManifest(source) {
     const docs = [];
     const boundaries = [];
-    for (const m of source.matchAll(new RegExp(DOC_SEPARATOR, "gm")))
-        boundaries.push(m.index, m.index + m[0].length);
+    for (const line of sourceLines(source)) {
+        if (DOC_SEPARATOR.test(line.content))
+            boundaries.push(line.start, line.end);
+    }
     const starts = [0, ...boundaries.filter((_, i) => i % 2 === 1)];
     const ends = [...boundaries.filter((_, i) => i % 2 === 0), source.length];
     for (let i = 0; i < starts.length; i++) {

package/dist/integrations/gitignore.js

@@ -15,6 +15,7 @@
 import { readFileSync, existsSync, lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { writeFileAtomic } from "../core/io.js";
+import { lineContent } from "../core/eol.js";
 import { gitTrackedPaths, gitUntrackCached, isGitRepoRoot } from "../extractors/git.js";
 const MARK = "# >>> hunch (derived runtime index — regenerable from .hunch/*.json) >>>";
 const END = "# <<< hunch <<<";
@@ -116,7 +117,7 @@ export function assertSafeTopLevelConfigFile(root, name) {
     }
     return path;
 }
-const cleanLine = (line) => line.replace(/\r$/, "").trim();
+const cleanLine = (line) => lineContent(line).trim();
 /** Locate a managed block as whole lines: the marker line and the FIRST end-marker
  *  line after it. `null` when either is missing — a hand-damaged block is never
  *  guessed at (con_8460b6770f). Indices are into `text.split("\n")`, whose items

package/dist/integrations/hooks.js

@@ -20,6 +20,7 @@ import { homedir } from "node:os";
 import { hooksDir, gitCommonDir, isLinkedWorktree, mainWorktreeRoot } from "../extractors/git.js";
 import { initiatorChildEnv } from "../synthesis/initiator.js";
 import { HUNCH_NPX_PACKAGE_SPEC, HUNCH_PACKAGE_NAME } from "../core/version.js";
+import { normalizeEol } from "../core/eol.js";
 const MARK = "# >>> hunch post-commit >>>";
 const ENDMARK = "# <<< hunch post-commit <<<";
 const GIT_CONTEXT = { checkoutType: "$3", portable: false };
@@ -73,7 +74,7 @@ const BLOCK_CLOSE = /^(?:fi|esac|done)\b|^\}|[;\s](?:fi|esac|done|\})\s*;?\s*$/;
  *  or a trailing top-level `if … else … fi` whose every branch ends in
  *  `exec`/`exit` — the shape of the pre-commit framework's generated hook. */
 export function terminalExitLine(content) {
-    const lines = content.replace(/\r/g, "").split("\n");
+    const lines = normalizeEol(content).split("\n");
     let depth = 0;
     for (const raw of lines) {
         const line = raw.trim();
@@ -386,7 +387,7 @@ function blockFlags(line) {
 function builtFlags(blk, mark, liveRoot) {
     const { re } = blockSubcommand(mark);
     const found = new Set();
-    for (const line of blk.replace(/\r/g, "").split("\n")) {
+    for (const line of normalizeEol(blk).split("\n")) {
         if (line.trim().startsWith("#"))
             continue;
         const m = re.exec(line);
@@ -417,7 +418,7 @@ function inspectBlock(file, mark, root) {
     const { re, words } = blockSubcommand(mark);
     const text = readText(file) ?? "";
     const at = text.indexOf(mark);
-    const body = at < 0 ? [] : text.slice(at).replace(/\r/g, "").split("\n").slice(1);
+    const body = at < 0 ? [] : normalizeEol(text.slice(at)).split("\n").slice(1);
     let first = null;
     for (const line of body) {
         if (/^# <<< hunch /.test(line))
@@ -511,7 +512,7 @@ function worktreeTops(root) {
     const out = gitRun(["worktree", "list", "--porcelain"], root).stdout;
     if (!out)
         return { linked: [], count: 0 };
-    const entries = out.replace(/\r/g, "").split(/\n\s*\n/).map((e) => e.split("\n"));
+    const entries = normalizeEol(out).split(/\n\s*\n/).map((e) => e.split("\n"));
     const parsed = entries
         .map((lines) => ({
         path: lines.find((l) => l.startsWith("worktree "))?.slice("worktree ".length) ?? "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "1.41.5",
+  "version": "1.41.6",
   "mcpName": "io.github.davesheffer/hunch",
   "license": "Apache-2.0",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://www.hunchmemory.com",
-  "version": "1.41.5",
+  "version": "1.41.6",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@davesheffer/hunch",
-      "version": "1.41.5",
+      "version": "1.41.6",
       "runtimeHint": "npx",
       "packageArguments": [
         {