specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/delivery/runtime/local-restore-branch.js

@@ -0,0 +1,325 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreCommitMessage = restoreCommitMessage;
+exports.restoreWorktreesRoot = restoreWorktreesRoot;
+exports.pathsWithMarkers = pathsWithMarkers;
+exports.prepareRestoreBranch = prepareRestoreBranch;
+exports.restoreFileChanges = restoreFileChanges;
+exports.commitRestoreBranch = commitRestoreBranch;
+exports.bringBackRestoreBranch = bringBackRestoreBranch;
+exports.removeRestoreBranch = removeRestoreBranch;
+/**
+ * Server-side restoration of a conflicting "Integrate locally" stash
+ * (proactive-local-integration). Git effects only — the caller owns the
+ * repository lock, the durable record and the decision lease.
+ *
+ * Specrails never delegates these writes to the (read-only) mission agent:
+ *  1. `prepareRestoreBranch` cuts `specrails/restore-local-<sha8>` from the
+ *     integrated target in a separate worktree and runs `git stash apply <sha>`
+ *     there. Specrails-managed generated files take the integrated version;
+ *     an untracked-vs-tracked collision is turned into an ordinary two-sided
+ *     conflict block so it can be resolved like any other.
+ *  2. Remaining conflicts are handed to a write-capable resolver confined to
+ *     that worktree (see local-restore-resolver.ts); `commitRestoreBranch`
+ *     then verifies no marker/unmerged path is left and commits on the branch.
+ *  3. Only the person's click brings it back (`bringBackRestoreBranch`, a
+ *     fast-forward of the target) or discards it (`discardRestoreBranch`).
+ * The stash itself is never popped, dropped or cleared here.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const worktree_manager_1 = require("../../../worktree-manager");
+const local_stash_1 = require("./local-stash");
+const SHA_RE = /^[0-9a-f]{40,64}$/i;
+const MARKER_RE = /^(?:<{7}|>{7})(?: |$)/m;
+function restoreCommitMessage(ticketIds) {
+    const tickets = ticketIds.length > 0 ? ticketIds.map((id) => `#${id}`).join(', ') : 'the delivery';
+    return `Restore local changes from before integrating ${tickets}`;
+}
+/** `<root>/restore-local-<sha8>` — the mount root under the project's worktrees area. */
+function restoreWorktreesRoot(worktreesRoot, sha) {
+    return path.join(worktreesRoot, `restore-local-${sha.slice(0, 8)}`);
+}
+async function head(git, cwd) {
+    const r = await (0, local_stash_1.safeRun)(git, ['rev-parse', '--verify', 'HEAD^{commit}'], cwd);
+    const sha = r.code === 0 ? r.stdout.trim() : '';
+    return SHA_RE.test(sha) ? sha : null;
+}
+async function branchTip(git, repo, branch) {
+    const r = await (0, local_stash_1.safeRun)(git, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}^{commit}`], repo);
+    const sha = r.code === 0 ? r.stdout.trim() : '';
+    return SHA_RE.test(sha) ? sha : null;
+}
+function readText(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/** Paths whose working copy still carries conflict markers (unreadable ⇒ suspect). */
+function pathsWithMarkers(cwd, paths) {
+    return paths.filter((p) => {
+        const abs = path.join(cwd, p);
+        if (!fs.existsSync(abs))
+            return false;
+        try {
+            if (!fs.statSync(abs).isFile())
+                return false;
+        }
+        catch {
+            return true;
+        }
+        const text = readText(abs);
+        return text === null ? true : MARKER_RE.test(text);
+    });
+}
+/**
+ * Create the restore branch + worktree from `targetBranch` and apply the
+ * stash there. Never touches the person's checkout or the target branch.
+ */
+async function prepareRestoreBranch(git, input) {
+    const branch = (0, local_stash_1.restoreBranchName)(input.sha);
+    if (await branchTip(git, input.repo, branch)) {
+        // Never borrow (or overwrite) a branch Specrails did not just create.
+        return { ok: false, branch, detail: `The branch ${branch} already exists; discard it or rename it, then restore again.` };
+    }
+    let worktreePath;
+    try {
+        const handle = await (0, worktree_manager_1.createWorktree)(git, {
+            repoDir: input.repo,
+            worktreesRoot: restoreWorktreesRoot(input.worktreesRoot, input.sha),
+            slug: 'restore-local',
+            ticketId: input.ticketId,
+            baseRef: input.targetBranch,
+            branch,
+            fresh: true,
+        });
+        worktreePath = handle.worktreePath;
+    }
+    catch (err) {
+        return { ok: false, branch, detail: err instanceof Error ? err.message : String(err) };
+    }
+    const baseSha = await head(git, worktreePath);
+    if (!baseSha)
+        return { ok: false, branch, worktreePath, detail: 'The restore worktree has no readable HEAD.' };
+    const carried = await (0, local_stash_1.stashPaths)(git, input.repo, input.sha);
+    if (!carried)
+        return { ok: false, branch, worktreePath, detail: 'The saved changes could not be read.' };
+    // Untracked files of the stash that the integrated tree now tracks make
+    // `git stash apply` refuse outright. In this disposable worktree, set the
+    // integrated copy aside, apply, then write both sides as a conflict block.
+    const collisions = new Map();
+    for (const file of carried.untracked.keys()) {
+        const abs = path.join(worktreePath, file);
+        if (!fs.existsSync(abs))
+            continue;
+        const text = readText(abs);
+        if (text === null)
+            return { ok: false, branch, worktreePath, detail: `Cannot read ${file} in the restore worktree.` };
+        collisions.set(file, text);
+        fs.rmSync(abs, { force: true });
+    }
+    const applied = await (0, local_stash_1.safeRun)(git, ['stash', 'apply', '--quiet', input.sha], worktreePath);
+    const unmerged = await (0, local_stash_1.unmergedPaths)(git, worktreePath);
+    if (!unmerged)
+        return { ok: false, branch, worktreePath, detail: 'git could not list conflicts in the restore worktree.' };
+    if (applied.code !== 0 && unmerged.length === 0) {
+        return { ok: false, branch, worktreePath, detail: `Applying the saved changes failed: ${(0, local_stash_1.failureText)(applied)}` };
+    }
+    const collided = [];
+    for (const [file, integrated] of collisions) {
+        const abs = path.join(worktreePath, file);
+        const local = readText(abs);
+        if (local === null || local === integrated) {
+            fs.writeFileSync(abs, integrated);
+            continue;
+        }
+        if ((0, local_stash_1.isSpecrailsManagedPath)(file)) {
+            fs.writeFileSync(abs, integrated);
+            continue;
+        }
+        const nl = (s) => s.endsWith('\n') ? s : `${s}\n`;
+        fs.writeFileSync(abs, `<<<<<<< integrated (${input.targetBranch})\n${nl(integrated)}=======\n${nl(local)}>>>>>>> local changes\n`);
+        collided.push(file);
+    }
+    const managedUnmerged = unmerged.filter(local_stash_1.isSpecrailsManagedPath);
+    const managedCollided = [...collisions.keys()].filter((f) => (0, local_stash_1.isSpecrailsManagedPath)(f));
+    if (managedUnmerged.length > 0) {
+        const settled = await (0, local_stash_1.resetPathsToHead)(git, worktreePath, managedUnmerged);
+        if (settled)
+            return { ok: false, branch, worktreePath, detail: settled };
+    }
+    const remaining = [...new Set([...unmerged.filter((p) => !(0, local_stash_1.isSpecrailsManagedPath)(p)), ...collided])];
+    return {
+        ok: true, branch, worktreePath, baseSha,
+        conflictPaths: remaining.slice(0, 20),
+        managedPaths: [...new Set([...managedUnmerged, ...managedCollided])].slice(0, 50),
+    };
+}
+async function restoreFileChanges(git, cwd, from, to) {
+    const r = await (0, local_stash_1.safeRun)(git, ['diff', '--numstat', '-z', '--no-renames', from, to, '--'], cwd);
+    if (r.code !== 0)
+        return [];
+    const files = [];
+    for (const entry of (0, local_stash_1.nulList)(r.stdout)) {
+        const [added, removed, ...rest] = entry.split('\t');
+        const file = rest.join('\t');
+        if (!file)
+            continue;
+        files.push({ path: file, added: /^\d+$/.test(added) ? Number(added) : null, removed: /^\d+$/.test(removed) ? Number(removed) : null });
+        if (files.length >= 50)
+            break;
+    }
+    return files;
+}
+/**
+ * Verify the restore worktree is still on its branch with no conflict left,
+ * then commit whatever is not committed yet (the resolver may already have).
+ */
+async function commitRestoreBranch(git, input) {
+    const { worktreePath } = input;
+    if (!fs.existsSync(worktreePath))
+        return { ok: false, detail: 'The restore worktree no longer exists.' };
+    const on = await (0, local_stash_1.safeRun)(git, ['symbolic-ref', '--quiet', 'HEAD'], worktreePath);
+    if (on.code !== 0 || on.stdout.trim() !== `refs/heads/${input.branch}`) {
+        return { ok: false, detail: `The restore worktree is no longer on ${input.branch}.` };
+    }
+    const tip = await head(git, worktreePath);
+    if (!tip)
+        return { ok: false, detail: 'The restore worktree has no readable HEAD.' };
+    const ancestry = await (0, local_stash_1.safeRun)(git, ['merge-base', '--is-ancestor', input.baseSha, tip], worktreePath);
+    if (ancestry.code !== 0)
+        return { ok: false, detail: `${input.branch} no longer descends from the integrated target.` };
+    // A resolved-but-unstaged path is still "unmerged" in the index: the
+    // working copy (no markers) is what counts, then it is staged.
+    const before = await (0, local_stash_1.unmergedPaths)(git, worktreePath);
+    if (!before)
+        return { ok: false, detail: 'git could not list conflicts in the restore worktree.' };
+    const marked = pathsWithMarkers(worktreePath, [...new Set([...input.conflictPaths, ...before])]);
+    if (marked.length > 0) {
+        return { ok: false, detail: 'Conflict markers are still present.', conflictPaths: marked.slice(0, 20) };
+    }
+    if (before.length > 0) {
+        const staged = await (0, local_stash_1.safeRun)(git, ['add', '-A', '--', ...before.map((p) => `:(top,literal)${p}`)], worktreePath);
+        if (staged.code !== 0)
+            return { ok: false, detail: `Staging resolved files: ${(0, local_stash_1.failureText)(staged)}` };
+    }
+    const unmerged = await (0, local_stash_1.unmergedPaths)(git, worktreePath);
+    if (!unmerged || unmerged.length > 0) {
+        return { ok: false, detail: 'Unmerged paths remain.', conflictPaths: (unmerged ?? before).slice(0, 20) };
+    }
+    const committed = await (0, worktree_manager_1.commitWorktreeAndVerify)(git, worktreePath, input.message);
+    if (committed.error || !committed.clean) {
+        return { ok: false, detail: `Committing the restored changes: ${committed.error ?? committed.dirty.slice(0, 5).join(', ')}` };
+    }
+    const commitSha = await head(git, worktreePath);
+    if (!commitSha)
+        return { ok: false, detail: 'The restore commit could not be read.' };
+    return { ok: true, commitSha, files: await restoreFileChanges(git, worktreePath, input.baseSha, commitSha) };
+}
+/**
+ * Fast-forward the person's target checkout to the reviewed restore commit.
+ * When the target moved meanwhile, the target is merged INTO the restore
+ * branch first (in its worktree; aborted on conflict) so the target itself
+ * only ever fast-forwards. Overlapping uncommitted edits refuse.
+ */
+async function bringBackRestoreBranch(git, input) {
+    const { checkout } = input;
+    if (!fs.existsSync(checkout))
+        return { ok: false, reason: 'unavailable', detail: 'The checkout no longer exists.' };
+    const on = await (0, local_stash_1.safeRun)(git, ['symbolic-ref', '--quiet', 'HEAD'], checkout);
+    const current = on.code === 0 ? on.stdout.trim().replace(/^refs\/heads\//, '') : null;
+    if (current !== input.targetBranch) {
+        return { ok: false, reason: 'wrong_branch', current, detail: `The checkout is on ${current ?? 'a detached HEAD'}, not ${input.targetBranch}.` };
+    }
+    const tip = await branchTip(git, input.repo, input.branch);
+    if (tip !== input.commitSha) {
+        return { ok: false, reason: 'branch_changed', detail: `${input.branch} changed since it was prepared; review it again.` };
+    }
+    const targetHead = await head(git, checkout);
+    if (!targetHead)
+        return { ok: false, reason: 'unavailable', detail: 'The target branch has no readable HEAD.' };
+    let commitSha = input.commitSha;
+    const ff = await (0, local_stash_1.safeRun)(git, ['merge-base', '--is-ancestor', targetHead, commitSha], checkout);
+    if (ff.code !== 0) {
+        if (!fs.existsSync(input.worktreePath)) {
+            return { ok: false, reason: 'target_conflict', detail: `${input.targetBranch} moved and the restore worktree is gone.` };
+        }
+        const merged = await (0, local_stash_1.safeRun)(git, ['merge', '--no-edit', '--no-ff', input.targetBranch], input.worktreePath);
+        if (merged.code !== 0) {
+            await (0, local_stash_1.safeRun)(git, ['merge', '--abort'], input.worktreePath);
+            return { ok: false, reason: 'target_conflict', detail: `${input.targetBranch} moved and no longer merges cleanly with ${input.branch}.` };
+        }
+        const next = await head(git, input.worktreePath);
+        if (!next)
+            return { ok: false, reason: 'unavailable', detail: 'The merged restore commit could not be read.' };
+        commitSha = next;
+    }
+    const changed = await (0, local_stash_1.safeRun)(git, ['diff', '--name-only', '-z', '--no-renames', targetHead, commitSha, '--'], checkout);
+    const dirty = await (0, local_stash_1.listUserDirtyPaths)(git, checkout);
+    if (changed.code !== 0 || !dirty)
+        return { ok: false, reason: 'unavailable', detail: 'git could not compare the checkout.' };
+    if ((0, local_stash_1.pathsOverlap)(dirty, (0, local_stash_1.nulList)(changed.stdout))) {
+        return { ok: false, reason: 'dirty', detail: 'Files the restored changes touch have uncommitted edits in the checkout.' };
+    }
+    const advanced = await (0, local_stash_1.safeRun)(git, ['merge', '--ff-only', '--no-overwrite-ignore', commitSha], checkout);
+    if (advanced.code !== 0) {
+        return { ok: false, reason: /would be overwritten|local changes|untracked working tree/i.test(`${advanced.stderr}\n${advanced.stdout}`) ? 'dirty' : 'unavailable', detail: (0, local_stash_1.failureText)(advanced) };
+    }
+    return { ok: true, commitSha, warnings: await removeRestoreBranch(git, input.repo, input.worktreePath, input.branch, false) };
+}
+/**
+ * Unmount the restore worktree and delete its branch. `force` (the person's
+ * explicit discard) also drops unmerged work on it; otherwise only a merged
+ * branch is deleted (`branch -d`). Returns warnings; never throws.
+ */
+async function removeRestoreBranch(git, repo, worktreePath, branch, force) {
+    const warnings = [];
+    if (worktreePath && fs.existsSync(worktreePath)) {
+        const removed = await (0, local_stash_1.safeRun)(git, ['worktree', 'remove', ...(force ? ['--force'] : []), worktreePath], repo);
+        if (removed.code !== 0)
+            warnings.push(`restore worktree ${worktreePath}: ${(0, local_stash_1.failureText)(removed)}`);
+    }
+    await (0, local_stash_1.safeRun)(git, ['worktree', 'prune'], repo);
+    if (await branchTip(git, repo, branch)) {
+        const deleted = await (0, local_stash_1.safeRun)(git, ['branch', force ? '-D' : '-d', branch], repo);
+        if (deleted.code !== 0)
+            warnings.push(`restore branch ${branch}: ${(0, local_stash_1.failureText)(deleted)}`);
+    }
+    return warnings;
+}

package/server/dist/modules/delivery/runtime/local-restore-resolver.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLocalRestoreResolver = void 0;
+exports.buildLocalRestoreResolverPrompt = buildLocalRestoreResolverPrompt;
+/**
+ * The write-capable conflict resolver for a conflicting "Integrate locally"
+ * stash restore (proactive-local-integration). It is the same AI
+ * merge-resolver the parallel-rail merge-back uses (`{{cmd:resolve-merge}}`
+ * with the MERGE_SAFE contract, spawned through the loop executors' headless
+ * rail-job path, i.e. with write permissions), confined to the restore
+ * worktree: cwd and repoDir are that worktree, never the person's checkout.
+ *
+ * Mission agents are read-only and are never asked to do this.
+ */
+const loop_command_catalog_1 = require("../../loops/runtime/loop-command-catalog");
+const loop_constants_1 = require("../../loops/runtime/loop-constants");
+const loop_executors_1 = require("../../loops/runtime/loop-executors");
+const provider_selection_1 = require("../../../provider-selection");
+const spec_models_1 = require("../../specs/runtime/spec-models");
+/** The resolver prompt (agent-facing, English like every briefing). */
+function buildLocalRestoreResolverPrompt(input, provider) {
+    const resolveMerge = (0, loop_constants_1.resolveConstants)((0, loop_command_catalog_1.expandCommands)('{{cmd:resolve-merge}}', { provider }), loop_constants_1.BUILTIN_CONSTANTS);
+    return [
+        resolveMerge,
+        '',
+        `Context: this worktree is on \`${input.branch}\`, cut from the integrated \`${input.targetBranch}\`. The person's uncommitted changes from before integrating ("${input.stashName}") were applied on top and conflicted.`,
+        'Keep BOTH intents: the integrated code and the person\'s local edits. Conflicting files:',
+        ...input.conflictPaths.map((p) => `- ${p}`),
+        '',
+        'Rules:',
+        '- Work only inside this worktree and only on those files; do not switch branches, do not touch any other branch or worktree.',
+        '- Run nothing destructive: no `git reset --hard`, `git checkout -- .`, `git clean`, `git stash drop/pop/clear`, `git push` or file deletions.',
+        `- When every conflict marker is gone, stage the files and commit on \`${input.branch}\` (Specrails verifies and commits anything left).`,
+    ].join('\n');
+}
+/** Default: the project's machine-primary provider and its default model. */
+const defaultLocalRestoreResolver = async (input) => {
+    const provider = (0, provider_selection_1.defaultMachineProvider)();
+    const model = (0, spec_models_1.getProviderDefault)(provider);
+    await (0, loop_executors_1.createLoopExecutors)().runAiStep({
+        prompt: buildLocalRestoreResolverPrompt(input, provider),
+        provider,
+        model,
+        cwd: input.worktreePath,
+        repoDir: input.worktreePath,
+    });
+};
+exports.defaultLocalRestoreResolver = defaultLocalRestoreResolver;