@opengsd/gsd-core 1.5.0 → 1.6.0-rc.2

package/gsd-core/bin/lib/runtime-name-policy.cjs

@@ -17,6 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canonicalizeRuntimeName = canonicalizeRuntimeName;
 exports.resolveRuntimeNameFromCandidates = resolveRuntimeNameFromCandidates;
+exports.getDirName = getDirName;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const FALLBACK_ALIASES = {
@@ -95,3 +96,46 @@ function resolveRuntimeNameFromCandidates(...candidates) {
     }
     return null;
 }
+/**
+ * Map a canonical runtime id to its on-disk local config directory name
+ * (e.g. `cursor` -> `.cursor`, `windsurf` -> `.devin`). Unknown/empty inputs
+ * fall back to `.claude`.
+ *
+ * Pure runtime-identity projection. Relocated from `bin/install.js` per
+ * ADR-1508 (epic #1507, #1510 Phase 1) so the Runtime Artifact Conversion
+ * Module's rewrite engine can consume it without importing the installer.
+ * `bin/install.js` re-exports this same function for back-compat.
+ */
+function getDirName(runtime) {
+    if (runtime === 'copilot')
+        return '.github';
+    if (runtime === 'opencode')
+        return '.opencode';
+    if (runtime === 'gemini')
+        return '.gemini';
+    if (runtime === 'kilo')
+        return '.kilo';
+    if (runtime === 'codex')
+        return '.codex';
+    if (runtime === 'antigravity')
+        return '.agents';
+    if (runtime === 'cursor')
+        return '.cursor';
+    if (runtime === 'windsurf')
+        return '.devin';
+    if (runtime === 'augment')
+        return '.augment';
+    if (runtime === 'trae')
+        return '.trae';
+    if (runtime === 'qwen')
+        return '.qwen';
+    if (runtime === 'hermes')
+        return '.hermes';
+    if (runtime === 'kimi')
+        return '.kimi-code';
+    if (runtime === 'codebuddy')
+        return '.codebuddy';
+    if (runtime === 'cline')
+        return '.cline';
+    return '.claude';
+}

package/gsd-core/bin/lib/semver-compare.cjs

@@ -14,6 +14,7 @@ exports.toNumericTuple = toNumericTuple;
 exports.compareSemverCore = compareSemverCore;
 exports.isSemverNewer = isSemverNewer;
 exports.isStableTripletSemver = isStableTripletSemver;
+exports.semverSatisfies = semverSatisfies;
 function toNumericTuple(input) {
     const cleaned = String(input == null ? '' : input).trim().replace(/^v/, '');
     const base = cleaned.replace(/[-+].*$/, '');
@@ -40,3 +41,129 @@ function isSemverNewer(a, b) {
 function isStableTripletSemver(v) {
     return /^\d+\.\d+\.\d+$/.test(String(v || '').replace(/^v/, ''));
 }
+function compareTuples(a, b) {
+    if (a[0] !== b[0])
+        return a[0] > b[0] ? 1 : -1;
+    if (a[1] !== b[1])
+        return a[1] > b[1] ? 1 : -1;
+    if (a[2] !== b[2])
+        return a[2] > b[2] ? 1 : -1;
+    return 0;
+}
+// Parse a version-ish token into a tuple + how many leading numeric parts were
+// specified (0 = bare wildcard "*"/"x", 1 = "1", 2 = "1.2", 3 = "1.2.3").
+// Returns null if the token is not a parseable partial/full version.
+function parseVersionToken(token) {
+    const clean = token.trim().replace(/^v/, '').replace(/[-+].*$/, '');
+    if (clean === '' || clean === '*' || clean === 'x' || clean === 'X')
+        return { tuple: [0, 0, 0], specified: 0 };
+    const parts = clean.split('.');
+    if (parts.length > 3)
+        return null;
+    const nums = [];
+    let sawWildcard = false;
+    for (const p of parts) {
+        if (p === 'x' || p === 'X' || p === '*') {
+            sawWildcard = true;
+            continue;
+        }
+        // A concrete segment after a wildcard ("1.x.2", "1.*.2") is malformed → fail closed.
+        if (sawWildcard)
+            return null;
+        if (!/^\d+$/.test(p))
+            return null;
+        nums.push(Number.parseInt(p, 10));
+    }
+    if (nums.length === 0)
+        return { tuple: [0, 0, 0], specified: 0 };
+    return { tuple: [nums[0] || 0, nums[1] || 0, nums[2] || 0], specified: nums.length };
+}
+// Expand a single comparator into primitive (op, tuple) constraints, or null if
+// unparseable (→ fail closed).
+function expandComparator(c) {
+    const trimmed = c.trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'x' || trimmed === 'X')
+        return [{ op: '>=', t: [0, 0, 0] }];
+    const m = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(trimmed);
+    if (!m)
+        return null;
+    const op = m[1] || '';
+    const pv = parseVersionToken(m[2]);
+    if (!pv)
+        return null;
+    const { tuple, specified } = pv;
+    const [maj, min, pat] = tuple;
+    if (op === '^') {
+        let upper;
+        if (maj > 0)
+            upper = [maj + 1, 0, 0];
+        else if (min > 0)
+            upper = [0, min + 1, 0];
+        else
+            upper = [0, 0, pat + 1];
+        return [{ op: '>=', t: tuple }, { op: '<', t: upper }];
+    }
+    if (op === '~') {
+        const upper = specified >= 2 ? [maj, min + 1, 0] : [maj + 1, 0, 0];
+        return [{ op: '>=', t: tuple }, { op: '<', t: upper }];
+    }
+    if (op === '' || op === '=') {
+        if (specified === 0)
+            return [{ op: '>=', t: [0, 0, 0] }]; // "*" → any
+        if (specified === 3)
+            return [{ op: '=', t: tuple }];
+        const upper = specified === 1 ? [maj + 1, 0, 0] : [maj, min + 1, 0];
+        return [{ op: '>=', t: tuple }, { op: '<', t: upper }];
+    }
+    // >= <= > < with an explicit version
+    if (specified === 0)
+        return null; // e.g. ">=*" is meaningless → fail closed
+    return [{ op: op, t: tuple }];
+}
+function satisfiesPrimitive(v, prim) {
+    const cmp = compareTuples(v, prim.t);
+    switch (prim.op) {
+        case '>=': return cmp >= 0;
+        case '<=': return cmp <= 0;
+        case '>': return cmp > 0;
+        case '<': return cmp < 0;
+        case '=': return cmp === 0;
+        default: return false;
+    }
+}
+// One whitespace-separated comparator set (ANDed). Fail closed if any comparator
+// is unparseable.
+function satisfiesSet(v, set) {
+    const trimmed = set.trim();
+    if (trimmed === '')
+        return false;
+    const comparators = trimmed.split(/\s+/).filter(Boolean);
+    if (comparators.length === 0)
+        return false;
+    for (const c of comparators) {
+        const prims = expandComparator(c);
+        if (prims === null)
+            return false; // unparseable → fail closed
+        for (const prim of prims) {
+            if (!satisfiesPrimitive(v, prim))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Does `version` satisfy the semver `range`? OR-composed across `||`, AND-composed
+ * across whitespace. Fail-closed: an empty range, or any comparator this minimal
+ * implementation cannot parse, returns false. Comparison is on the numeric
+ * major.minor.patch core (prerelease tags are stripped, per `toNumericTuple`).
+ */
+function semverSatisfies(version, range) {
+    const r = String(range == null ? '' : range).trim();
+    if (r === '')
+        return false;
+    const v = toNumericTuple(version);
+    const orSets = r.split('||').map((s) => s.trim()).filter((s) => s.length > 0);
+    if (orSets.length === 0)
+        return false;
+    return orSets.some((set) => satisfiesSet(v, set));
+}

package/gsd-core/bin/lib/shell-command-projection.cjs

@@ -510,13 +510,49 @@ function normalizeContent(filePath, content, opts = {}) {
     }
     return { content: normalized, encoding };
 }
+// Rename errnos that are transient on Windows: a concurrent reader (or an AV
+// scanner / indexer) holding the target open makes renameSync fail briefly.
+// Same idiom as capability-ledger.cts / capability-consent.cts.
+const RENAME_RETRY_ERRNOS = new Set(['EPERM', 'EBUSY', 'EACCES']);
+const RENAME_MAX_ATTEMPTS = 3;
+const RENAME_RETRY_BACKOFF_MS = 50;
+/** Synchronous best-effort backoff sleep (Atomics.wait — same idiom as io.cts). */
+let _renameSleepBuf = null;
+function renameBackoff() {
+    if (_renameSleepBuf === null)
+        _renameSleepBuf = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(_renameSleepBuf, 0, 0, RENAME_RETRY_BACKOFF_MS);
+}
+/**
+ * Atomic publish with bounded retry on transient Windows lock errnos.
+ * Returns null on success, or the final error if every attempt failed.
+ */
+function atomicRenameWithRetry(tmpPath, filePath) {
+    let renameErr = null;
+    for (let attempt = 1; attempt <= RENAME_MAX_ATTEMPTS; attempt++) {
+        try {
+            node_fs_1.default.renameSync(tmpPath, filePath);
+            return null;
+        }
+        catch (err) {
+            renameErr = err;
+            if (attempt < RENAME_MAX_ATTEMPTS && RENAME_RETRY_ERRNOS.has(renameErr.code ?? '')) {
+                renameBackoff();
+                continue;
+            }
+            break;
+        }
+    }
+    return renameErr;
+}
 function platformWriteSync(filePath, content, opts = {}) {
     const { content: normalized, encoding } = normalizeContent(filePath, content, opts);
     node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
     const tmpPath = filePath + '.tmp.' + process.pid;
+    // Step 1: write the sibling tmp file. If THIS fails, nothing was published, so a
+    // direct fallback write cannot truncate a concurrent reader of an existing file.
     try {
         node_fs_1.default.writeFileSync(tmpPath, normalized, encoding);
-        node_fs_1.default.renameSync(tmpPath, filePath);
     }
     catch {
         try {
@@ -524,7 +560,25 @@ function platformWriteSync(filePath, content, opts = {}) {
         }
         catch { /* already gone */ }
         node_fs_1.default.writeFileSync(filePath, normalized, encoding);
+        return;
+    }
+    // Step 2: atomic publish, retrying transient Windows locks.
+    const renameErr = atomicRenameWithRetry(tmpPath, filePath);
+    if (renameErr === null)
+        return;
+    try {
+        node_fs_1.default.unlinkSync(tmpPath);
+    }
+    catch { /* already gone */ }
+    if (RENAME_RETRY_ERRNOS.has(renameErr.code ?? '')) {
+        // A live reader still holds the target open after every retry. A non-atomic
+        // direct write here would truncate that reader (the exact corruption this seam
+        // exists to prevent), so surface the error instead of falling back.
+        throw renameErr;
     }
+    // Atomic publish is genuinely impossible here (e.g. EXDEV cross-device move):
+    // fall back to a direct write to preserve write availability.
+    node_fs_1.default.writeFileSync(filePath, normalized, encoding);
 }
 function platformReadSync(filePath, opts = {}) {
     const encoding = opts.encoding ?? 'utf-8';

package/gsd-core/bin/lib/state-document.cjs

@@ -153,8 +153,10 @@ function shouldPreserveExistingProgress(existingProgress, derivedProgress) {
         return false;
     const existing = existingProgress;
     const derived = derivedProgress;
-    return (existingProgressExceedsDerived(existing, derived, 'total_phases') ||
-        existingProgressExceedsDerived(existing, derived, 'completed_phases') ||
+    // total_phases is intentionally excluded from the ratchet: it must always
+    // take the freshly derived value so it can correct downward (#1446).
+    // Only completed_phases, total_plans, and completed_plans keep ratchet behaviour.
+    return (existingProgressExceedsDerived(existing, derived, 'completed_phases') ||
         existingProgressExceedsDerived(existing, derived, 'total_plans') ||
         existingProgressExceedsDerived(existing, derived, 'completed_plans'));
 }