@opengsd/gsd-core 1.10.0 → 1.12.0

package/gsd-core/bin/lib/text-lines.cjs

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * text-lines.cts — the line-terminator seam (ADR-3212 §3, epic #3212 Phase 2,
+ * #3413).
+ *
+ * Source in src/text-lines.cts, compiled to gsd-core/bin/lib/text-lines.cjs
+ * (gitignored), per the repo's ADR-457 build-at-publish convention.
+ *
+ * Sole owner of `\r?\n` splitting and CRLF normalization. Closes #3360: a
+ * regex anchored on `^`/`$` under `/m` against a whole multi-line string is
+ * exposed to `\r` being its own LineTerminator (ECMA-262), so a greedy `\s*`
+ * can cross a CRLF boundary and inflate a captured indent by one character.
+ * Split-then-match — call `splitLines` first, then match per already-split
+ * line — is immune by construction, because a single split line can never
+ * contain the delimiter that produced it. This module exists so that shape
+ * is the easy, obvious way to write indentation-sensitive parsing, per the
+ * design doc (.gsd/phase/chore-3413-text-lines-seam/40-design.md).
+ *
+ * A "genuine leaf" module (CONTEXT.md's term, shared with Phase 1's sibling
+ * seam `src/pattern.cts`): zero I/O, zero imports from other `src/*.cts`
+ * modules, pure string functions only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLines = splitLines;
+exports.normalizeEol = normalizeEol;
+exports.detectEol = detectEol;
+exports.joinLines = joinLines;
+/**
+ * Split document content into lines on `\r\n` or `\n`. A lone `\r` (bare CR,
+ * no following `\n`) is NOT a delimiter — this matches every existing
+ * `\r?\n` call site in the repo and is intentionally narrower than "treat
+ * any LineTerminator as a break." Matches `String.prototype.split`'s own
+ * contract for a trailing terminator (a trailing empty element) and for the
+ * empty string (`[""]`).
+ */
+function splitLines(content) {
+    if (typeof content !== 'string') {
+        throw new TypeError(`splitLines: expected a string, got ${typeof content}`);
+    }
+    return content.split(/\r?\n/);
+}
+/**
+ * Normalize all line endings to LF by stripping every `\r` character — not
+ * only `\r\n` pairs. This is byte-for-byte the same operation as the 4
+ * `scripts/gen-*.cjs` copies of `normalizeLineEndings` this module
+ * consolidates (`content.replace(/\r/g, '')`), so a lone/unpaired `\r` (old
+ * Mac-style content) is stripped too. Deliberately a different contract from
+ * `splitLines`, which does NOT treat a bare `\r` as a delimiter (row 6) —
+ * these are two different operations kept as two separate functions rather
+ * than one "handle all CR-ish things" primitive.
+ */
+function normalizeEol(content) {
+    return content.replace(/\r/g, '');
+}
+/**
+ * Detect the dominant line-terminator in `content`: `'\r\n'` when CRLF pairs
+ * outnumber bare LFs, `'\n'` when bare LFs outnumber CRLF pairs, and `'\r\n'`
+ * as the default when there is no bare LF at all (all-CRLF content, or no
+ * terminator present whatsoever — an empty or single-line input). See the
+ * design doc's Rejected section for why the tie/empty default is `'\r\n'`
+ * rather than `'\n'`: this function exists to PRESERVE whatever a file
+ * already uses, not to bias toward LF the way a write-time normalizer would.
+ */
+function detectEol(content) {
+    const crlfCount = (content.match(/\r\n/g) || []).length;
+    const totalLfCount = (content.match(/\n/g) || []).length;
+    const bareLfCount = totalLfCount - crlfCount;
+    if (bareLfCount === 0 || crlfCount >= bareLfCount)
+        return '\r\n';
+    return '\n';
+}
+/**
+ * Join lines back into a single string with `eol` (default `'\n'`) between
+ * each pair — the inverse of `splitLines`. `joinLines(splitLines(x),
+ * detectEol(x))` reproduces `x` byte-for-byte for any `x` already in
+ * canonical (single-terminator) form (ADR-3212 §3's round-trip property).
+ */
+function joinLines(lines, eol) {
+    return lines.join(eol ?? '\n');
+}

package/gsd-core/bin/lib/token-scanner.cjs

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * token-scanner.cts — the tokenizer-first seam for stateful grammars (ADR-3212
+ * §4, epic #3212 Phase 3, #3414).
+ *
+ * Source in src/token-scanner.cts, compiled to gsd-core/bin/lib/token-scanner.cjs
+ * (gitignored), per the repo's ADR-457 build-at-publish convention.
+ *
+ * Generalizes the proven `hooks/lib/git-cmd.js` token-walk (#3129 — "has not
+ * re-opened") into a primitive other stateful-grammar consumers can share.
+ * `git-cmd.js` migrates onto `tokenizeShellLike` with zero behavior change
+ * (ADR §6); its own env-prefix/flag/subcommand walk logic stays put — only
+ * the character-level tokenizer moves here.
+ *
+ * `indentWidth` is the primitive `src/decisions.cts`'s #3169 fix needs: a
+ * decision-bullet list can NEST (a bullet elaborating on an already-open
+ * decision, indented deeper than it), and a per-line regex cannot see that
+ * nesting — only tracking indentation relative to the currently-open
+ * decision can (ADR §4 criterion 1). See
+ * .gsd/phase/chore-3414-tokenizer-first-seam/40-design.md §1.3 for the
+ * disproven bold-run-content-classification alternative and why nesting
+ * depth, not bullet content, is the actual distinguishing signal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeShellLike = tokenizeShellLike;
+exports.indentWidth = indentWidth;
+/**
+ * Tokenize a shell-like command string: whitespace-split, with single- and
+ * double-quoted spans taken as one token each. No escape handling, no
+ * brace/variable expansion — matches `hooks/lib/git-cmd.js`'s original
+ * `tokenize()` exactly (parity-asserted in tests/token-scanner.test.cjs).
+ */
+function tokenizeShellLike(cmd) {
+    const tokens = [];
+    let i = 0;
+    const len = cmd.length;
+    while (i < len) {
+        while (i < len && /\s/.test(cmd[i]))
+            i++;
+        if (i >= len)
+            break;
+        let token = '';
+        while (i < len && !/\s/.test(cmd[i])) {
+            if (cmd[i] === "'") {
+                i++;
+                while (i < len && cmd[i] !== "'")
+                    token += cmd[i++];
+                if (i < len)
+                    i++;
+            }
+            else if (cmd[i] === '"') {
+                i++;
+                while (i < len && cmd[i] !== '"')
+                    token += cmd[i++];
+                if (i < len)
+                    i++;
+            }
+            else {
+                token += cmd[i++];
+            }
+        }
+        if (token)
+            tokens.push(token);
+    }
+    return tokens;
+}
+/**
+ * Count a line's leading whitespace width. Tabs count as one column each
+ * (not expanded) — matches `src/decisions.cts`'s existing continuation-line
+ * check (`/^[ \t]/`), which never expanded tabs either; this function does
+ * not introduce a new tab-width policy.
+ */
+function indentWidth(line) {
+    const match = line.match(/^[ \t]*/);
+    return match ? match[0].length : 0;
+}

package/gsd-core/bin/lib/uat-predicate.cjs

@@ -25,6 +25,12 @@ const { stripFencedCode } = markdownSectionizer;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const verification = require("./verification.cjs");
 const { readVerificationStatus } = verification;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const phaseIdMod = require("./phase-id.cjs");
+const { scopeToPhase } = phaseIdMod;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const coreUtils = require("./core-utils.cjs");
+const { normalizeLineEndings } = coreUtils;
 // ─── Blocking state sets (documented for maintainability) ─────────────────────
 // UAT file frontmatter `status` values that indicate the file is not fully done
 const BLOCKING_UAT_FM_STATUSES = new Set([
@@ -109,32 +115,62 @@ function analyzeMarkdown(raw) {
  */
 function parseUatResultItems(cleanContent) {
     const items = [];
-    // Find all ### N. Name headings (line-anchored)
-    const headingPattern = /^###\s*(\d+)\.\s*(.+)$/gm;
+    // Find all ### N. Name headings.
+    // #3078-CR MEDIUM (security review follow-up): STRUCTURE and ATTRIBUTION
+    // need different split frames. This is a STRUCTURE scan — finding where a
+    // heading block begins — and there is no attribution distinction to
+    // preserve, so split on any of `\n`, U+2028, U+2029: a heading delimited by
+    // an exotic line separator (origin/next's `/m`-anchored scan found these;
+    // a naive `split('\n')`-only port silently stopped finding them, making the
+    // gate MORE permissive than origin/next) is found exactly like a
+    // `\n`-delimited one. Contrast the `result:` scan below, which is an
+    // ATTRIBUTION scan and must NOT do this.
+    const HEADING_LINE_RE = /^###\s*(\d+)\.\s*(.+)$/;
     const headings = [];
-    let hMatch;
-    while ((hMatch = headingPattern.exec(cleanContent)) !== null) {
-        headings.push({
-            index: hMatch.index + hMatch[0].length,
-            test: parseInt(hMatch[1], 10),
-            name: hMatch[2].trim(),
-        });
+    {
+        // All three separators are exactly one UTF-16 code unit, so the
+        // `line.length + 1` offset arithmetic below stays valid regardless of
+        // which separator terminated a given line.
+        const lines = cleanContent.split(/[\n\u2028\u2029]/);
+        let offset = 0;
+        for (const line of lines) {
+            const hMatch = line.match(HEADING_LINE_RE);
+            if (hMatch) {
+                headings.push({
+                    index: offset + hMatch[0].length,
+                    lineStart: offset,
+                    test: parseInt(hMatch[1], 10),
+                    name: hMatch[2].trim(),
+                });
+            }
+            offset += line.length + 1; // +1 for the separator consumed by split
+        }
     }
     for (let i = 0; i < headings.length; i++) {
         const h = headings[i];
         const blockStart = h.index;
-        // More precise: find next heading's position in the original string
-        // We'll slice from current heading end to the position just before next heading's "###"
-        const nextHeadingMatch = i + 1 < headings.length
-            ? cleanContent.lastIndexOf('\n###', headings[i + 1].index)
-            : -1;
-        const blockContent = nextHeadingMatch >= blockStart
-            ? cleanContent.slice(blockStart, nextHeadingMatch)
+        // A block spans until the START of the next heading's line (tracked
+        // directly from the same split-frame scan above), not a re-search for a
+        // literal '\n###' over unsplit text -- the latter would silently miss a
+        // next heading delimited by U+2028/U+2029 instead of '\n' and swallow
+        // every subsequent block into this one.
+        const blockContent = i + 1 < headings.length
+            ? cleanContent.slice(blockStart, headings[i + 1].lineStart)
             : cleanContent.slice(blockStart);
-        // Column-0 anchored result line: /^result:[ \t]*\[?([\w-]+)\]?/mi
+        // Column-0 result line, split-then-match (#3078-CR MEDIUM — same fix as
+        // the heading scan above): test each already-split line individually
+        // against a single-line (no `/m` anchor) pattern instead of anchoring
+        // over unsplit `blockContent`, so a `result:`-shaped line reachable only
+        // via a U+2028/U+2029 separator inside an `expected: |` scalar body can
+        // never register as a fake column-0 match. FIRST MATCH WINS — no
+        // ambiguity counting, matching src/uat.cts's contract.
         // Uses [ \t]* (not \s*) so the captured value must sit on the SAME line as result:.
         // A result: key with the value on a subsequent line yields no match → 'missing' (blocker).
-        const resultMatch = /^result:[ \t]*\[?([\w-]+)\]?/mi.exec(blockContent);
+        const RESULT_LINE_RE = /^result:[ \t]*\[?([\w-]+)\]?/i;
+        const resultMatch = blockContent
+            .split('\n')
+            .map((line) => line.match(RESULT_LINE_RE))
+            .find((m) => m !== null) ?? null;
         if (resultMatch) {
             items.push({
                 test: h.test,
@@ -190,16 +226,23 @@ function evaluateUatPassed(phaseFullDir, opts) {
             verification_stale_check_indeterminate: false,
         };
     }
-    // Filter UAT and VERIFICATION files using the same filter as cmdPhaseComplete
-    const uatFileNames = dirEntries.filter(f => f.includes('-UAT') && f.endsWith('.md'));
-    const verFileNames = dirEntries.filter(f => f.includes('-VERIFICATION') && f.endsWith('.md'));
+    // Filter UAT and VERIFICATION files using the same filter as cmdPhaseComplete,
+    // scoped to THIS phase's own token (#3511) — a stray, cross-phase, or ad-hoc
+    // file can no longer contribute a blocker to a phase it does not belong to.
+    const phaseDirBaseName = node_path_1.default.basename(phaseFullDir);
+    const uatFileNames = scopeToPhase(dirEntries.filter(f => f.includes('-UAT') && f.endsWith('.md')), phaseDirBaseName);
+    const verFileNames = scopeToPhase(dirEntries.filter(f => f.includes('-VERIFICATION') && f.endsWith('.md')), phaseDirBaseName);
     // ── Process UAT files ──────────────────────────────────────────────────────
     for (const file of uatFileNames) {
         uatFiles.push(file);
         const uatFilePath = node_path_1.default.join(phaseFullDir, file);
         let raw = '';
         try {
-            raw = node_fs_1.default.readFileSync(uatFilePath, 'utf-8');
+            // #3078-CR MEDIUM: normalize line endings at the read boundary — the
+            // same seam src/uat.cts and src/verification.cts route through — so a
+            // lone-CR *-UAT.md is not read as one unbroken line by the column-0
+            // scans below.
+            raw = normalizeLineEndings(node_fs_1.default.readFileSync(uatFilePath, 'utf-8'));
         }
         catch {
             blockers.push(`${file}: could not read file`);
@@ -246,7 +289,8 @@ function evaluateUatPassed(phaseFullDir, opts) {
         const verificationFilePath = node_path_1.default.join(phaseFullDir, file);
         let raw = '';
         try {
-            raw = node_fs_1.default.readFileSync(verificationFilePath, 'utf-8');
+            // #3078-CR MEDIUM: same read-boundary normalization as the UAT loop above.
+            raw = normalizeLineEndings(node_fs_1.default.readFileSync(verificationFilePath, 'utf-8'));
         }
         catch {
             blockers.push(`${file}: could not read verification file`);