@therocketcode/gsd-core 1.4.0

package/gsd-core/bin/lib/worktree-base-ref.cjs

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * Worktree base-ref detection and degradation logic (issue #683).
+ *
+ * Determines whether a worktree's HEAD has drifted from the fork base that the
+ * Claude Code harness would use to create a 'fresh' parallel worktree. When
+ * drift is detected the caller should fall back to sequential execution on the
+ * main working tree to avoid a base mismatch.
+ *
+ * Pure/testable module: all I/O is injectable via the `deps` argument so unit
+ * tests can run without touching the real filesystem or spawning real git.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortSha = shortSha;
+exports.readBaseRefFromSettings = readBaseRefFromSettings;
+exports.applyWorktreeBaseRef = applyWorktreeBaseRef;
+exports.resolveEffectiveBaseRef = resolveEffectiveBaseRef;
+exports.cmdWorktreeBaseCheck = cmdWorktreeBaseCheck;
+exports.cmdWorktreeSetBaseRef = cmdWorktreeSetBaseRef;
+exports.evaluateWorktreeBaseDegrade = evaluateWorktreeBaseDegrade;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+/**
+ * Strip JSONC comments (line and block forms) from a string to produce valid JSON.
+ * Handles comments inside strings correctly (does not strip them).
+ * Mirrors the same logic in bin/install.js:stripJsonComments.
+ */
+function stripJsonComments(text) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    let stringChar = '';
+    while (i < text.length) {
+        // Handle string literals — don't strip comments inside strings
+        if (inString) {
+            if (text[i] === '\\') {
+                result += text[i] + (text[i + 1] || '');
+                i += 2;
+                continue;
+            }
+            if (text[i] === stringChar) {
+                inString = false;
+            }
+            result += text[i];
+            i++;
+            continue;
+        }
+        // Start of string
+        if (text[i] === '"' || text[i] === "'") {
+            inString = true;
+            stringChar = text[i];
+            result += text[i];
+            i++;
+            continue;
+        }
+        // Line comment
+        if (text[i] === '/' && text[i + 1] === '/') {
+            // Skip to end of line
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            continue;
+        }
+        // Block comment
+        if (text[i] === '/' && text[i + 1] === '*') {
+            i += 2;
+            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
+                i++;
+            i += 2; // skip closing */
+            continue;
+        }
+        result += text[i];
+        i++;
+    }
+    // Remove trailing commas before } or ] (common in JSONC)
+    return result.replace(/,\s*([}\]])/g, '$1');
+}
+/**
+ * Parse a string as JSONC (JSON with comments). Returns the parsed value or
+ * throws a SyntaxError if the content is genuinely malformed.
+ */
+function parseJsonc(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return JSON.parse(stripJsonComments(text));
+    }
+}
+// ─── Message constants (verbatim — downstream docs/tests depend on these) ─────
+function buildMsgDiverged(headSha, forkRef, forkSha) {
+    return `⚠ Worktree base mismatch: HEAD (${shortSha(headSha)}) differs from ${forkRef} (${shortSha(forkSha)}). Running this phase sequentially on the main working tree. To keep parallel worktrees, set worktree.baseRef:"head" in .claude/settings.local.json (or run: gsd-tools worktree set-baseref). See #683.`;
+}
+const MSG_UNKNOWN = `⚠ Cannot determine the worktree fork base (origin/HEAD unresolved). Running this phase sequentially on the main working tree to avoid a base mismatch. To keep parallel worktrees, set worktree.baseRef:"head" in .claude/settings.local.json (or run: gsd-tools worktree set-baseref). See #683.`;
+// ─── Exports ──────────────────────────────────────────────────────────────────
+/**
+ * Returns the first 8 characters of a SHA, or '' if null/empty.
+ */
+function shortSha(sha) {
+    if (!sha)
+        return '';
+    return sha.slice(0, 8);
+}
+/**
+ * Extracts settings.worktree.baseRef if it is a string; otherwise null.
+ * Defensive: settings may be null/undefined, worktree may be missing or
+ * not an object.
+ */
+function readBaseRefFromSettings(settings) {
+    if (settings == null || typeof settings !== 'object')
+        return null;
+    const s = settings;
+    if (s.worktree == null || typeof s.worktree !== 'object' || Array.isArray(s.worktree))
+        return null;
+    const worktree = s.worktree;
+    if (typeof worktree.baseRef !== 'string')
+        return null;
+    return worktree.baseRef;
+}
+/**
+ * No-clobber application of worktree.baseRef = 'head'.
+ *
+ * - If baseRef is absent/null/undefined → set to 'head', return changed:true.
+ * - If already 'head' → skip, return skipped:'already-head'.
+ * - If any other string → skip without overwriting, return skipped:'explicit-other'.
+ *
+ * Mutates `settings` in place and also returns it.
+ */
+function applyWorktreeBaseRef(settings) {
+    // Defensive: caller must pass a plain object — reject null, arrays, and primitives.
+    if (settings === null || Array.isArray(settings) || typeof settings !== 'object') {
+        throw new TypeError(`applyWorktreeBaseRef: expected a plain object, got ${settings === null ? 'null' : Array.isArray(settings) ? 'array' : typeof settings}`);
+    }
+    // Ensure worktree object exists, preserving any existing keys
+    if (settings.worktree == null || typeof settings.worktree !== 'object' || Array.isArray(settings.worktree)) {
+        settings.worktree = {};
+    }
+    const worktree = settings.worktree;
+    const current = typeof worktree.baseRef === 'string' ? worktree.baseRef : null;
+    if (current === 'head') {
+        return { changed: false, settings, skipped: 'already-head', previous: 'head' };
+    }
+    if (current !== null) {
+        // Some other explicit string value — don't overwrite
+        return { changed: false, settings, skipped: 'explicit-other', previous: current };
+    }
+    // Absent/null/undefined → set to 'head'
+    worktree.baseRef = 'head';
+    return { changed: true, settings, skipped: null, previous: null };
+}
+/**
+ * Reads settings.local.json then settings.json under claudeDir, extracts
+ * worktree.baseRef from the first file that provides a non-null string value.
+ *
+ * deps.readFile(path) must return the file contents or null on any error.
+ */
+function resolveEffectiveBaseRef(claudeDir, deps) {
+    const readFile = deps?.readFile ?? ((p) => {
+        try {
+            return node_fs_1.default.readFileSync(p, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    });
+    const localPath = node_path_1.default.join(claudeDir, 'settings.local.json');
+    const sharedPath = node_path_1.default.join(claudeDir, 'settings.json');
+    function parseBaseRef(filePath) {
+        const contents = readFile(filePath);
+        if (contents == null)
+            return null;
+        try {
+            const parsed = parseJsonc(contents);
+            return readBaseRefFromSettings(parsed);
+        }
+        catch {
+            return null;
+        }
+    }
+    const localRef = parseBaseRef(localPath);
+    if (localRef !== null)
+        return localRef;
+    return parseBaseRef(sharedPath);
+}
+/**
+ * CLI command: check current worktree base-ref degradation status.
+ *
+ * Reads effective baseRef from <cwd>/.claude settings, runs degradation
+ * evaluation, writes JSON result to stdout (or injected write), and returns
+ * the result object.
+ */
+function cmdWorktreeBaseCheck(cwd, _args, deps) {
+    const claudeDir = node_path_1.default.join(cwd, '.claude');
+    const effectiveBaseRef = resolveEffectiveBaseRef(claudeDir, deps?.readFile ? { readFile: deps.readFile } : undefined);
+    const result = evaluateWorktreeBaseDegrade({
+        cwd,
+        effectiveBaseRef,
+        execGit: deps?.execGit,
+    });
+    const write = deps?.write ?? ((s) => process.stdout.write(s));
+    write(JSON.stringify(result, null, 2) + '\n');
+    return result;
+}
+/**
+ * CLI command: write worktree.baseRef = 'head' into <cwd>/.claude/settings.local.json.
+ *
+ * No-clobber: if the file already has an explicit baseRef that is not 'head',
+ * the existing value is preserved and output reflects skipped:'explicit-other'.
+ * If the file contains malformed JSON, throws a clear error rather than
+ * silently clobbering the user's file.
+ */
+function cmdWorktreeSetBaseRef(cwd, _args, deps) {
+    const file = node_path_1.default.join(cwd, '.claude', 'settings.local.json');
+    const readFile = deps?.readFile ??
+        ((p) => { try {
+            return node_fs_1.default.readFileSync(p, 'utf8');
+        }
+        catch {
+            return null;
+        } });
+    const raw = readFile(file);
+    let settings = {};
+    if (raw != null) {
+        let parsed;
+        try {
+            parsed = parseJsonc(raw);
+        }
+        catch {
+            throw new Error(`Refusing to modify ${file}: existing JSON is malformed`);
+        }
+        if (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object') {
+            throw new Error(`Refusing to modify ${file}: expected a JSON object at the top level`);
+        }
+        settings = parsed;
+    }
+    const apply = applyWorktreeBaseRef(settings);
+    if (apply.changed) {
+        const dir = node_path_1.default.dirname(file);
+        const existsSync = deps?.existsSync ?? node_fs_1.default.existsSync;
+        const mkdirFn = deps?.mkdir ??
+            ((p, opts) => { node_fs_1.default.mkdirSync(p, opts); });
+        if (!existsSync(dir)) {
+            mkdirFn(dir, { recursive: true });
+        }
+        const writeFile = deps?.writeFile ??
+            ((p, content) => { node_fs_1.default.writeFileSync(p, content, 'utf8'); });
+        writeFile(file, JSON.stringify(settings, null, 2) + '\n');
+    }
+    const output = {
+        changed: apply.changed,
+        skipped: apply.skipped,
+        previous: apply.previous,
+        baseRef: 'head',
+        file,
+    };
+    const write = deps?.write ?? ((s) => process.stdout.write(s));
+    write(JSON.stringify(output, null, 2) + '\n');
+    return output;
+}
+/**
+ * Evaluates whether the current worktree HEAD has diverged from the fork base
+ * (origin/HEAD) that the Claude Code harness would use when creating a 'fresh'
+ * parallel worktree.
+ *
+ * Returns a structured result with shouldDegrade, reason, and a user-visible
+ * message when degradation is warranted.
+ */
+function evaluateWorktreeBaseDegrade(deps) {
+    const execGit = deps?.execGit ?? shell_command_projection_cjs_1.execGit;
+    const cwd = deps?.cwd;
+    const cwdOpts = cwd ? { cwd } : {};
+    // a. If baseRef is explicitly 'head' the harness forks from HEAD — no mismatch possible.
+    // Claude Code's worktree.baseRef accepts only "fresh" (= origin/HEAD, the default) or "head".
+    // Therefore special-casing "head" here and otherwise comparing HEAD against origin/HEAD is
+    // complete: any non-"head" value (including "fresh" and absent/null) has fresh/origin-HEAD
+    // semantics and must be evaluated against origin/HEAD. (Reference: Claude Code worktrees docs, #683.)
+    if (deps?.effectiveBaseRef === 'head') {
+        return { shouldDegrade: false, reason: 'baseref-head', message: null, headSha: null, forkRef: null, forkSha: null };
+    }
+    // b. Resolve HEAD sha.
+    const headResult = execGit(['rev-parse', 'HEAD'], cwdOpts);
+    const headStdout = headResult.stdout ? headResult.stdout.trim() : '';
+    if (headResult.exitCode !== 0 || !headStdout) {
+        return { shouldDegrade: false, reason: 'no-head', message: null, headSha: null, forkRef: null, forkSha: null };
+    }
+    const headSha = headStdout;
+    // c. Resolve fork base (what the harness forks 'fresh' worktrees from = origin/HEAD).
+    let forkRef = null;
+    let forkSha = null;
+    // Try direct origin/HEAD rev-parse first.
+    const directResult = execGit(['rev-parse', '--verify', '--quiet', 'origin/HEAD'], cwdOpts);
+    const directStdout = directResult.stdout ? directResult.stdout.trim() : '';
+    if (directResult.exitCode === 0 && directStdout) {
+        forkRef = 'origin/HEAD';
+        forkSha = directStdout;
+    }
+    else {
+        // Fall back via symbolic-ref → refs/remotes/origin/HEAD
+        const symResult = execGit(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], cwdOpts);
+        const symStdout = symResult.stdout ? symResult.stdout.trim() : '';
+        if (symResult.exitCode === 0 && symStdout) {
+            const ref = symStdout;
+            const symShaResult = execGit(['rev-parse', '--verify', '--quiet', ref], cwdOpts);
+            const symShaStdout = symShaResult.stdout ? symShaResult.stdout.trim() : '';
+            if (symShaResult.exitCode === 0 && symShaStdout) {
+                // Strip leading 'refs/remotes/' to get e.g. 'origin/next'
+                forkRef = ref.replace(/^refs\/remotes\//, '');
+                forkSha = symShaStdout;
+            }
+        }
+    }
+    // d. Evaluate.
+    if (forkSha === null) {
+        return { shouldDegrade: true, reason: 'fork-ref-unknown', message: MSG_UNKNOWN, headSha, forkRef: null, forkSha: null };
+    }
+    if (forkSha === headSha) {
+        return { shouldDegrade: false, reason: 'head-matches-fork', message: null, headSha, forkRef, forkSha };
+    }
+    const message = buildMsgDiverged(headSha, forkRef, forkSha);
+    return { shouldDegrade: true, reason: 'head-diverged-from-fork', message, headSha, forkRef, forkSha };
+}