vibe-coding-master 0.4.19 → 0.4.20

package/dist/backend/services/harness-service.js

@@ -258,6 +258,9 @@ export function createHarnessService(deps) {
         async getRepositoryDiff(repoRoot, input = {}) {
             return getRepositoryDiffReport(requireRepositoryDiffGit(deps.git), repoRoot, input, now());
         },
+        async mergeRepositoryDiffToCurrentBranch(baseRepoRoot, input) {
+            return mergeRepositoryDiffToCurrentBranch(requireRepositoryMergeGit(deps.git), baseRepoRoot, input, now());
+        },
         async getBootstrapStatus(repoRoot, targetRepoRoot = repoRoot) {
             return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
         },
@@ -454,6 +457,7 @@ function requireRepositoryDiffGit(git) {
     if (!git?.getCommitDiff ||
         !git.getCommitInfo ||
         !git.getCommitList ||
+        !git.getCurrentBranch ||
         !git.getHeadCommit ||
         !git.getMergeBase) {
         throw new VcmError({
@@ -464,7 +468,22 @@ function requireRepositoryDiffGit(git) {
     }
     return git;
 }
+function requireRepositoryMergeGit(git) {
+    if (!git?.branchExists ||
+        !git.getCurrentBranch ||
+        !git.getHeadCommit ||
+        !git.mergeBranchFastForward) {
+        throw new VcmError({
+            code: "HARNESS_GIT_UNAVAILABLE",
+            message: "Git-backed repository merge is not available in this VCM runtime.",
+            statusCode: 501
+        });
+    }
+    return git;
+}
 async function getRepositoryDiffReport(git, repoRoot, input, generatedAt) {
+    const sourceBranch = await git.getCurrentBranch(repoRoot);
+    const targetBranch = input.baseRepoRoot ? await git.getCurrentBranch(input.baseRepoRoot) : sourceBranch;
     const baseRef = input.baseRepoRoot
         ? await git.getHeadCommit(input.baseRepoRoot)
         : "HEAD^";
@@ -476,6 +495,8 @@ async function getRepositoryDiffReport(git, repoRoot, input, generatedAt) {
         return {
             version: 1,
             repoRoot,
+            sourceBranch,
+            targetBranch,
             generatedAt,
             commits,
             summary: createEmptyRepositoryDiffSummary(),
@@ -497,6 +518,8 @@ async function getRepositoryDiffReport(git, repoRoot, input, generatedAt) {
     return {
         version: 1,
         repoRoot,
+        sourceBranch,
+        targetBranch,
         generatedAt,
         commits,
         commit: {
@@ -522,6 +545,71 @@ async function getRepositoryDiffReport(git, repoRoot, input, generatedAt) {
         warnings
     };
 }
+async function mergeRepositoryDiffToCurrentBranch(git, baseRepoRoot, input, mergedAt) {
+    const taskBranch = input.taskBranch.trim();
+    if (!taskBranch) {
+        throw new VcmError({
+            code: "HARNESS_MERGE_SOURCE_BRANCH_MISSING",
+            message: "Task branch is missing.",
+            statusCode: 400
+        });
+    }
+    if (!(await git.branchExists(baseRepoRoot, taskBranch))) {
+        throw new VcmError({
+            code: "HARNESS_MERGE_SOURCE_BRANCH_MISSING",
+            message: `Task branch does not exist locally: ${taskBranch}`,
+            statusCode: 409,
+            hint: "Create or restore the task branch before merging it into the connected repository branch."
+        });
+    }
+    const targetBranch = await git.getCurrentBranch(baseRepoRoot);
+    if (targetBranch === "detached") {
+        throw new VcmError({
+            code: "HARNESS_MERGE_BASE_DETACHED",
+            message: "The connected repository is in detached HEAD state.",
+            statusCode: 409,
+            hint: "Checkout the intended target branch in the connected repository before merging the task branch."
+        });
+    }
+    if (taskBranch === targetBranch) {
+        throw new VcmError({
+            code: "HARNESS_MERGE_BRANCH_INVALID",
+            message: "Task branch is already the connected repository branch.",
+            statusCode: 409,
+            hint: `Source and target are both ${targetBranch}.`
+        });
+    }
+    await assertVisibleWorktreeClean(git, input.taskRepoRoot, "The active task worktree", "HARNESS_MERGE_TASK_DIRTY");
+    await assertVisibleWorktreeClean(git, baseRepoRoot, "The connected repository", "HARNESS_MERGE_BASE_DIRTY");
+    const beforeSha = await git.getHeadCommit(baseRepoRoot);
+    const mergeResult = await git.mergeBranchFastForward(baseRepoRoot, taskBranch);
+    const afterSha = await git.getHeadCommit(baseRepoRoot);
+    return {
+        version: 1,
+        baseRepoRoot,
+        taskRepoRoot: input.taskRepoRoot,
+        sourceBranch: taskBranch,
+        targetBranch,
+        beforeSha,
+        afterSha,
+        changed: beforeSha !== afterSha,
+        stdout: mergeResult.stdout,
+        stderr: mergeResult.stderr,
+        mergedAt
+    };
+}
+async function assertVisibleWorktreeClean(git, repoRoot, label, code) {
+    const entries = await getVisibleGitStatusEntries(git, repoRoot);
+    if (entries.length === 0) {
+        return;
+    }
+    throw new VcmError({
+        code,
+        message: `${label} has uncommitted Git-visible changes.`,
+        statusCode: 409,
+        hint: `Commit or revert these files before merging to main: ${entries.map((entry) => entry.path).slice(0, 12).join(", ")}`
+    });
+}
 function toRepositoryDiffCommit(commit) {
     return {
         sha: commit.sha,

package/dist/backend/services/round-service.js

@@ -241,6 +241,36 @@ export function createRoundService(deps) {
         recordClaudeHookEvent(input) {
             return recordRoleTurnEvent(input);
         },
+        async setRoleRecovery(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                const next = {
+                    ...state,
+                    roleRecovery: normalizeRoleRecovery(input.recovery),
+                    updatedAt: timestamp
+                };
+                await save(input, next);
+                await updateSessionStatus(input, "running");
+                return toSessionRoundState(next, timestamp);
+            });
+        },
+        async clearRoleRecovery(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                if (!state.roleRecovery || (input.role && state.roleRecovery.role !== input.role)) {
+                    return toSessionRoundState(state, timestamp);
+                }
+                const next = {
+                    ...state,
+                    roleRecovery: undefined,
+                    updatedAt: timestamp
+                };
+                await save(input, next);
+                return toSessionRoundState(next, timestamp);
+            });
+        },
         stopSession() { },
         stopTask(taskSlug) {
             clearSettleTimersForTask(taskSlug);
@@ -352,6 +382,7 @@ function toSessionRoundState(state, updatedAt) {
             totalCompletedTurnCount: state.totalCompletedTurnCount,
             totalCcActiveMs: state.totalCcActiveMs,
             currentRoundCcActiveMs: 0,
+            roleRecovery: state.roleRecovery,
             roles: [],
             updatedAt
         };
@@ -379,6 +410,7 @@ function toSessionRoundState(state, updatedAt) {
         totalCompletedTurnCount: state.totalCompletedTurnCount,
         totalCcActiveMs: state.totalCcActiveMs + activeDurationMs,
         currentRoundCcActiveMs,
+        roleRecovery: state.roleRecovery,
         roles: current.roles,
         updatedAt
     };
@@ -394,9 +426,35 @@ function normalizeRoundFile(input, taskSlug, updatedAt) {
         totalTurnCount: normalizeNumber(input.totalTurnCount ?? legacy.totalPromptSubmitCount),
         totalCompletedTurnCount: normalizeNumber(input.totalCompletedTurnCount ?? legacy.totalStopCount),
         totalCcActiveMs: normalizeNumber(input.totalCcActiveMs),
+        roleRecovery: normalizeRoleRecovery(input.roleRecovery),
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : updatedAt
     };
 }
+function normalizeRoleRecovery(input) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const record = input;
+    if (typeof record.role !== "string" ||
+        (record.status !== "waiting" && record.status !== "retrying" && record.status !== "failed") ||
+        typeof record.lastFailureAt !== "string") {
+        return undefined;
+    }
+    return {
+        role: record.role,
+        status: record.status,
+        attempt: normalizeNumber(record.attempt),
+        maxAttempts: normalizeNumber(record.maxAttempts),
+        lastFailureAt: record.lastFailureAt,
+        error: typeof record.error === "string" ? record.error : undefined,
+        errorDetails: typeof record.errorDetails === "string" ? record.errorDetails : undefined,
+        lastAssistantMessage: typeof record.lastAssistantMessage === "string" ? record.lastAssistantMessage : undefined,
+        retryable: typeof record.retryable === "boolean" ? record.retryable : undefined,
+        nextRetryAt: typeof record.nextRetryAt === "string" ? record.nextRetryAt : undefined,
+        lastRetryAt: typeof record.lastRetryAt === "string" ? record.lastRetryAt : undefined,
+        failedAt: typeof record.failedAt === "string" ? record.failedAt : undefined
+    };
+}
 function normalizeRound(input) {
     if (!input || typeof input.id !== "string") {
         return undefined;