@opengsd/gsd-core 1.18.0 → 1.20.0

package/gsd-core/bin/lib/model-catalog.cjs

@@ -245,6 +245,14 @@ exports.EFFORT_ARGV = {
         supported: new Set(['low', 'medium', 'high', 'xhigh', 'max']),
         clamp: (level) => (level === 'minimal' ? 'low' : level),
     },
+    // Verified against `pi --help` (pi 1.3.0, #5557): `--thinking <level>` — "Set
+    // thinking level: off, minimal, low, medium, high, xhigh, max". `off` is a
+    // pi-only level with no universal counterpart, so it is not in `supported`.
+    pi: {
+        render: (level) => ['--thinking', level],
+        supported: new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']),
+        clamp: (level) => level,
+    },
 };
 /**
  * Clamp a universal effort level to what a host actually accepts, or null.

package/gsd-core/bin/lib/normalize-test-command.cjs

@@ -180,8 +180,75 @@ function normalizeTestCommand(rawCmd, cwd) {
 function cmdNormalizeTestCommand(cwd, rawCmd) {
     process.stdout.write(normalizeTestCommand(rawCmd ?? '', cwd));
 }
+const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'];
+// Lockfile order only matters when a project somehow carries several; the
+// `packageManager` field outranks all of them.
+const LOCKFILE_MANAGERS = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+];
+// The script name is spliced into a shell command by the caller, so it is
+// restricted to a plain identifier. Anything else is refused (empty output).
+const SCRIPT_NAME = /^[A-Za-z0-9_][A-Za-z0-9:_-]{0,63}$/;
+// Same bounded-read stance as the rest of this module: a package.json larger
+// than this is not a real manifest, so it is not parsed.
+const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
+function packageManagerFromField(cwd) {
+    try {
+        const pkgPath = node_path_1.default.join(cwd, 'package.json');
+        const stat = node_fs_1.default.statSync(pkgPath);
+        if (!stat.isFile() || stat.size > MAX_PACKAGE_JSON_BYTES)
+            return null;
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        if (typeof pkg !== 'object' || pkg === null)
+            return null;
+        const field = pkg.packageManager;
+        if (typeof field !== 'string')
+            return null;
+        const name = field.split('@')[0];
+        return PACKAGE_MANAGERS.includes(name) ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectPackageManager(cwd) {
+    const declared = packageManagerFromField(cwd);
+    if (declared)
+        return declared;
+    for (const [lockfile, manager] of LOCKFILE_MANAGERS) {
+        try {
+            if (node_fs_1.default.statSync(node_path_1.default.join(cwd, lockfile)).isFile())
+                return manager;
+        }
+        catch { /* absent: try the next lockfile */ }
+    }
+    return 'npm';
+}
+/**
+ * Command that runs package script `script` with the project's package manager.
+ * `test` uses the manager's short form where it has one; `bun test` is bun's
+ * own runner, not the package script, so bun always goes through `bun run`.
+ * Returns '' for a script name that is not a plain identifier.
+ */
+function resolvePackageManagerCommand(script, cwd) {
+    if (typeof script !== 'string' || !SCRIPT_NAME.test(script))
+        return '';
+    const manager = detectPackageManager(cwd);
+    if (script === 'test' && manager !== 'bun')
+        return `${manager} test`;
+    return `${manager} run ${script}`;
+}
+/** CLI handler for `gsd-tools query resolve-package-manager <script>`. */
+function cmdResolvePackageManager(cwd, script) {
+    process.stdout.write(resolvePackageManagerCommand(script ?? '', cwd));
+}
 module.exports = {
     normalizeTestCommand,
     cmdNormalizeTestCommand,
     isAlreadyOneShot,
+    resolvePackageManagerCommand,
+    cmdResolvePackageManager,
 };

package/gsd-core/bin/lib/phase-entry-grammar.cjs

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Phase-entry grammar — the one definition of a ROADMAP phase-list entry
+ * (`- [ ] **Phase 1: Name**`): bullet marker, checkbox, bold token and line
+ * anchoring (#5763, Phase 3 of epic #5692; census in #5703).
+ *
+ * Before this module every reader owned a private pattern, and the patterns
+ * disagreed on each axis (`-` only vs `[-*]`; required, optional or `\*{0,2}`
+ * bold; `[ x]` vs `[ xX]` vs `(x| )`; `^`-anchored vs the unanchored forms
+ * behind #4965 and #5545). Readers now compose their pattern from the prefix
+ * built here and keep only their own tail (label, id token, separator).
+ *
+ * The accepted grammar:
+ *   entry  := indent marker mgap box gap bold? gap <caller tail>
+ *   indent := [ \t]*                   — an entry starts its line
+ *   marker := '-' | '*'
+ *   mgap   := [ \t]{1,4}               — a list item: `-[ ]` is not one (#5764)
+ *   box    := '[' (' ' | 'x' | 'X') ']'
+ *   bold   := '**' | '__'              — a reader may require it
+ *   gap    := [ \t]*                   — horizontal whitespace only
+ * A reader that needs plain `- **Phase N**` bullets may make the box optional.
+ *
+ * Writers (flip, delete, renumber, id rewrite) compose their patterns here too
+ * (#5764, Phase 4): `phaseEntryRegExp` for a whole-line match and
+ * `phaseEntrySplitRegExp` when the writer rewrites the box and needs the text on
+ * either side of it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHASE_ENTRY_BOLD_CLOSE_SRC = exports.PHASE_ENTRY_BOLD_TOKEN_SRC = void 0;
+exports.phaseEntryPrefixSrc = phaseEntryPrefixSrc;
+exports.phaseEntryRegExp = phaseEntryRegExp;
+exports.phaseEntrySplitRegExp = phaseEntrySplitRegExp;
+exports.isPhaseEntryChecked = isPhaseEntryChecked;
+exports.isBoxCharChecked = isBoxCharChecked;
+const MARKER_SRC = '[-*]';
+// A list item has 1 to 4 spaces or tabs after its marker (CommonMark: none is not a list item,
+// five or more makes the rest an indented code block), so `-[ ] **Phase 1**` is not an entry.
+const MARKER_GAP_SRC = '[ \\t]{1,4}';
+const BOLD_TOKEN_SRC = '(?:\\*\\*|__)';
+/** Regex source of one bold token, for a reader that must also consume the closing wrapper. */
+exports.PHASE_ENTRY_BOLD_TOKEN_SRC = BOLD_TOKEN_SRC;
+/**
+ * Regex source of a closing bold wrapper for a reader that captures the entry's
+ * name up to it. `**` closes anywhere; `__` closes only at the end of the line,
+ * so a name that contains `__init__` or `__tests__` is not cut short.
+ */
+exports.PHASE_ENTRY_BOLD_CLOSE_SRC = '(?:\\*\\*|__(?=[ \\t]*\\r?$))';
+/**
+ * Line start, indent, marker and the marker's gap, up to where the box opens.
+ * A leading BOM can only precede the first line; it is not part of the grammar's indent.
+ */
+const LINE_OPEN_SRC = `^\\uFEFF?[ \\t]*${MARKER_SRC}${MARKER_GAP_SRC}`;
+/**
+ * Source for the bold token and its trailing gap. `(?:token[ \t]*)?` rather than
+ * `[ \t]*` + token + `[ \t]*`, which backtracks quadratically on a long blank run.
+ */
+function boldSrcFor(bold) {
+    return bold === 'required' ? `${BOLD_TOKEN_SRC}[ \\t]*` : `(?:${BOLD_TOKEN_SRC}[ \\t]*)?`;
+}
+/** Source for the box interior, honouring the requested state filter. */
+function stateSrc(state) {
+    if (state === 'unchecked')
+        return ' ';
+    if (state === 'checked')
+        return '[xX]';
+    if (state === 'captured')
+        return '([ xX])';
+    return '[ xX]';
+}
+/**
+ * Regex source of everything before the caller's `Phase`/label tail: line start, indent,
+ * marker, box, bold token and the horizontal gaps between them. A `captured`
+ * state adds exactly one capture group (the box character) at the front.
+ */
+function phaseEntryPrefixSrc(options = {}) {
+    const { bold = 'optional', box = 'required', state = 'any', decorated = false } = options;
+    // The decoration may not contain the word `Phase`, so the entry's own label is the first one
+    // on the line and `- [ ] **Phase 5**: needs Phase 2` is not an entry of phase 2. No gap
+    // before the run: `[ \t]*` then a lazy run overlap and backtrack quadratically.
+    if (decorated)
+        return `${LINE_OPEN_SRC}\\[${stateSrc(state)}\\](?:(?!Phase)[^\\r\\n])*?`;
+    const boxSrc = `\\[${stateSrc(state)}\\][ \\t]*`;
+    const body = box === 'optional' ? `(?:${boxSrc})?` : boxSrc;
+    return `${LINE_OPEN_SRC}${body}${boldSrcFor(bold)}`;
+}
+/**
+ * A RegExp for a phase entry: the grammar prefix followed by the caller's
+ * `tailSrc`. The `m` flag is always set, so `^` is a line start.
+ */
+function phaseEntryRegExp(tailSrc, flags = '', options = {}) {
+    const withM = flags.includes('m') ? flags : `${flags}m`;
+    return new RegExp(`${phaseEntryPrefixSrc(options)}${tailSrc}`, withM);
+}
+/**
+ * A RegExp for a phase entry a writer rewrites at the box: capture group 1 is
+ * everything through the opening `[` (indent, marker, gap) and capture group 2
+ * is everything from the closing `]` through the end of `tailSrc` (gap, bold
+ * token, label). A flip is `line.replace(re, '$1x$2')`; the box state itself is
+ * matched, not captured, so the writer chooses the new state. The `m` flag is
+ * always set.
+ */
+function phaseEntrySplitRegExp(tailSrc, flags = '', options = {}) {
+    const { bold = 'optional', state = 'any' } = options;
+    const withM = flags.includes('m') ? flags : `${flags}m`;
+    return new RegExp(`(${LINE_OPEN_SRC}\\[)${stateSrc(state)}(\\][ \\t]*${boldSrcFor(bold)}${tailSrc})`, withM);
+}
+const ENTRY_BOX_RE = new RegExp(`^\\uFEFF?[ \\t]*${MARKER_SRC}${MARKER_GAP_SRC}\\[([ xX])\\]`);
+/**
+ * Whether a phase entry line (or a regex match of one, which starts at the
+ * line) is ticked. The single place the box character is interpreted.
+ */
+function isPhaseEntryChecked(entryText) {
+    const m = ENTRY_BOX_RE.exec(entryText);
+    return m !== null && m[1].toLowerCase() === 'x';
+}
+/** Whether a captured box character (`captured` state option) is a tick. */
+function isBoxCharChecked(boxChar) {
+    return boxChar.toLowerCase() === 'x';
+}

package/gsd-core/bin/lib/phase-id-display.cjs

@@ -75,4 +75,6 @@ function renderBracketMilestoneDisplay(milestone, projectCode) {
 module.exports = {
     renderBracketPhaseDisplay,
     renderBracketMilestoneDisplay,
+    milestoneToken,
+    phaseToken,
 };