factory-factory 0.4.0 → 0.4.2

package/dist/src/backend/services/workspace/resources/workspace.accessor.js

@@ -1,10 +1,58 @@
 import { prisma } from '../../../../backend/db.js';
-import { KanbanColumn } from '../../../../shared/core/index.js';
+import { flattenWorkspaceAutoIteration, workspaceAutoIterationAccessor, } from '../../../../backend/services/workspace/resources/workspace-auto-iteration.accessor.js';
+import { flattenWorkspacePR, workspacePrAccessor, } from '../../../../backend/services/workspace/resources/workspace-pr.accessor.js';
+import { flattenWorkspaceRatchet, workspaceRatchetAccessor, } from '../../../../backend/services/workspace/resources/workspace-ratchet.accessor.js';
+import { flattenWorkspaceRunScript, workspaceRunScriptAccessor, } from '../../../../backend/services/workspace/resources/workspace-run-script.accessor.js';
+import { deriveRatchetState, } from '../../../../shared/core/index.js';
+const autoIterationExecutionContextSelect = {
+    worktreePath: true,
+    autoIteration: { select: { sessionId: true } },
+};
 const STALE_PROVISIONING_THRESHOLD_MS = 10 * 60 * 1000;
 const STALE_ARCHIVING_THRESHOLD_MS = 10 * 60 * 1000;
+function prAggregateChanged(current, observation) {
+    const compared = [
+        'prUrl',
+        'prNumber',
+        'prState',
+        'prReviewState',
+        'prCiStatus',
+        'prHasMergeConflict',
+    ];
+    return compared.some((field) => observation[field] !== undefined && current[field] !== observation[field]);
+}
+function flatten(row) {
+    const { ratchet, pr, runScript, autoIteration, ...rest } = row;
+    const ratchetFields = flattenWorkspaceRatchet(ratchet);
+    const prFields = flattenWorkspacePR(pr);
+    return {
+        ...rest,
+        ...ratchetFields,
+        ...prFields,
+        ...flattenWorkspaceRunScript(runScript),
+        ...flattenWorkspaceAutoIteration(autoIteration),
+        ratchetState: deriveRatchetState({
+            ratchetEnabled: ratchetFields.ratchetEnabled,
+            prState: prFields.prState,
+            prCiStatus: prFields.prCiStatus,
+            prHasMergeConflict: prFields.prHasMergeConflict,
+            prReviewState: prFields.prReviewState,
+        }),
+    };
+}
+const sideTables = {
+    ratchet: true,
+    pr: true,
+    runScript: true,
+    autoIteration: true,
+};
+function withProjectAndPR(row) {
+    const { pr, autoIteration, ...rest } = row;
+    return { ...rest, ...flattenWorkspacePR(pr), ...flattenWorkspaceAutoIteration(autoIteration) };
+}
 class WorkspaceAccessor {
-    create(data) {
-        return prisma.workspace.create({
+    async create(data) {
+        const created = await prisma.workspace.create({
             data: {
                 projectId: data.projectId,
                 name: data.name,
@@ -16,87 +64,149 @@ class WorkspaceAccessor {
                 linearIssueIdentifier: data.linearIssueIdentifier,
                 linearIssueUrl: data.linearIssueUrl,
                 isAutoGeneratedBranch: data.isAutoGeneratedBranch ?? false,
-                ratchetEnabled: data.ratchetEnabled,
+                ratchet: { create: { enabled: data.ratchetEnabled } },
+                pr: { create: {} },
+                runScript: { create: {} },
+                autoIteration: { create: { mode: data.mode, config: data.autoIterationConfig } },
                 defaultSessionProvider: data.defaultSessionProvider,
                 ratchetSessionProvider: data.ratchetSessionProvider,
                 creationSource: data.creationSource,
                 creationMetadata: data.creationMetadata,
-                mode: data.mode,
-                autoIterationConfig: data.autoIterationConfig,
                 periodicTaskId: data.periodicTaskId,
                 parentWorkspaceId: data.parentWorkspaceId,
             },
+            include: sideTables,
         });
+        return flatten(created);
     }
-    findById(id) {
-        return prisma.workspace.findUnique({
+    async findById(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
+                ...sideTables,
             },
         });
+        return row ? flatten(row) : null;
     }
     findRawById(id) {
         return prisma.workspace.findUnique({
             where: { id },
         });
     }
+    async exists(id) {
+        const workspace = await prisma.workspace.findUnique({
+            where: { id },
+            select: { id: true },
+        });
+        return workspace !== null;
+    }
+    findProviderSelection(id) {
+        return prisma.workspace.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                defaultSessionProvider: true,
+                ratchetSessionProvider: true,
+            },
+        });
+    }
+    findFixerContext(id) {
+        return prisma.workspace.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                worktreePath: true,
+                defaultSessionProvider: true,
+                ratchetSessionProvider: true,
+            },
+        });
+    }
+    async findStatusSnapshot(id) {
+        const row = await prisma.workspace.findUnique({
+            where: { id },
+            select: {
+                status: true,
+                initCompletedAt: true,
+                pr: { select: { url: true, number: true } },
+            },
+        });
+        if (!row) {
+            return null;
+        }
+        return {
+            status: row.status,
+            initCompletedAt: row.initCompletedAt,
+            prUrl: row.pr?.url ?? null,
+            prNumber: row.pr?.number ?? null,
+        };
+    }
+    async findPRContext(id) {
+        const row = await prisma.workspace.findUnique({
+            where: { id },
+            select: { branchName: true, pr: { select: { url: true } } },
+        });
+        return row ? { branchName: row.branchName, prUrl: row.pr?.url ?? null } : null;
+    }
     findRawByIdOrThrow(id) {
         return prisma.workspace.findUniqueOrThrow({
             where: { id },
         });
     }
-    findByProjectId(projectId, filters) {
-        const where = { projectId };
-        if (filters?.status) {
-            where.status = filters.status;
-        }
-        if (filters?.kanbanColumn) {
-            where.cachedKanbanColumn = filters.kanbanColumn;
+    async findAutoIterationExecutionContext(id) {
+        const workspace = await prisma.workspace.findUnique({
+            where: { id },
+            select: autoIterationExecutionContextSelect,
+        });
+        if (!workspace) {
+            return null;
         }
+        return {
+            worktreePath: workspace.worktreePath,
+            autoIterationSessionId: workspace.autoIteration?.sessionId ?? null,
+        };
+    }
+    findRunScriptExecutionState(id) {
+        return workspaceRunScriptAccessor.findExecutionState(id);
+    }
+    findRunScriptExecutionStateOrThrow(id) {
+        return workspaceRunScriptAccessor.findExecutionStateOrThrow(id);
+    }
+    findByProjectId(projectId) {
         return prisma.workspace.findMany({
-            where,
-            take: filters?.limit,
-            skip: filters?.offset,
+            where: { projectId },
             orderBy: { updatedAt: 'desc' },
         });
     }
-    findByProjectIdWithSessions(projectId, filters) {
-        if (filters?.status && filters?.excludeStatuses?.length) {
-            throw new Error('Cannot specify both status and excludeStatuses filters');
-        }
+    async findByProjectIdWithSessions(projectId, filters) {
         const where = { projectId };
-        if (filters?.status) {
-            where.status = filters.status;
-        }
         if (filters?.excludeStatuses && filters.excludeStatuses.length > 0) {
             where.status = { notIn: filters.excludeStatuses };
         }
-        if (filters?.kanbanColumn) {
-            where.cachedKanbanColumn = filters.kanbanColumn;
-        }
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where,
-            take: filters?.limit,
-            skip: filters?.offset,
             orderBy: { updatedAt: 'desc' },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
+                ...sideTables,
             },
         });
+        return rows.map(flatten);
     }
-    findAllNonArchivedWithSessionsAndProject() {
-        return prisma.workspace.findMany({
+    async findAllNonArchivedWithSessionsAndProject() {
+        const rows = await prisma.workspace.findMany({
             where: { status: { not: 'ARCHIVED' } },
             include: {
                 agentSessions: true,
                 terminalSessions: true,
                 project: true,
+                ...sideTables,
             },
             orderBy: { updatedAt: 'desc' },
         });
+        return rows.map(flatten);
     }
     update(id, data) {
         return prisma.workspace.update({
@@ -111,52 +221,37 @@ class WorkspaceAccessor {
         });
     }
     casRunScriptStatusUpdate(id, currentStatus, data) {
-        return prisma.workspace.updateMany({
-            where: { id, runScriptStatus: currentStatus },
-            data,
-        });
+        return workspaceRunScriptAccessor.casExecutionUpdate(id, currentStatus, data);
     }
-    async resetStaleAutoIterationStatuses() {
-        const stale = await prisma.workspace.findMany({
-            where: { autoIterationStatus: 'RUNNING' },
-            select: { id: true },
-        });
-        if (stale.length === 0) {
-            return [];
-        }
-        await prisma.workspace.updateMany({
-            where: {
-                id: { in: stale.map((w) => w.id) },
-                autoIterationStatus: 'RUNNING',
-            },
-            data: {
-                autoIterationStatus: 'FAILED',
-                autoIterationSessionId: null,
-            },
+    async registerInitializedWorktree(id, worktree, commands) {
+        await prisma.$transaction(async (transaction) => {
+            await transaction.workspace.update({ where: { id }, data: worktree });
+            await workspaceRunScriptAccessor.writeCommands(id, commands, transaction);
         });
-        return stale;
     }
-    async resetStaleRunScriptStatuses() {
-        const stale = await prisma.workspace.findMany({
-            where: { runScriptStatus: { in: ['STARTING', 'STOPPING'] } },
-            select: { id: true, runScriptStatus: true },
-        });
-        if (stale.length === 0) {
-            return [];
-        }
-        await prisma.workspace.updateMany({
-            where: {
-                id: { in: stale.map((w) => w.id) },
-                runScriptStatus: { in: ['STARTING', 'STOPPING'] },
-            },
-            data: {
-                runScriptStatus: 'IDLE',
-                runScriptPid: null,
-                runScriptPort: null,
-                runScriptStartedAt: null,
-            },
-        });
-        return stale;
+    setRunScriptCommands(id, commands) {
+        return workspaceRunScriptAccessor.writeCommands(id, commands);
+    }
+    setAutoIterationStatus(id, status) {
+        return workspaceAutoIterationAccessor.setStatus(id, status);
+    }
+    setAutoIterationProgress(id, progress) {
+        return workspaceAutoIterationAccessor.setProgress(id, progress);
+    }
+    setAutoIterationSessionId(id, sessionId) {
+        return workspaceAutoIterationAccessor.setSession(id, sessionId);
+    }
+    finishAutoIterationIfSessionMatches(id, sessionId, status) {
+        return workspaceAutoIterationAccessor.finishIfSessionMatches(id, sessionId, status);
+    }
+    clearAutoIterationSessionIfMatches(id, sessionId) {
+        return workspaceAutoIterationAccessor.clearSessionIfMatches(id, sessionId);
+    }
+    resetStaleAutoIterationStatuses() {
+        return workspaceAutoIterationAccessor.resetStaleRunningStatuses();
+    }
+    resetStaleRunScriptStatuses() {
+        return workspaceRunScriptAccessor.resetStaleTransientStatuses();
     }
     startProvisioningRetryIfAllowed(id, maxRetries) {
         return prisma.workspace.updateMany({
@@ -167,8 +262,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'PROVISIONING',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: new Date(),
                 initErrorMessage: null,
@@ -185,8 +278,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'PROVISIONING',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: new Date(),
                 initErrorMessage: null,
@@ -203,8 +294,6 @@ class WorkspaceAccessor {
             },
             data: {
                 status: 'NEW',
-                cachedKanbanColumn: KanbanColumn.WORKING,
-                stateComputedAt: new Date(),
                 initRetryCount: { increment: 1 },
                 initStartedAt: null,
                 initCompletedAt: null,
@@ -218,9 +307,9 @@ class WorkspaceAccessor {
             where: { id },
         });
     }
-    findNeedingWorktree() {
+    async findNeedingWorktree() {
         const staleThreshold = new Date(Date.now() - STALE_PROVISIONING_THRESHOLD_MS);
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 OR: [
                     { status: 'NEW' },
@@ -230,59 +319,29 @@ class WorkspaceAccessor {
                     },
                 ],
             },
-            include: {
-                project: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
             orderBy: { createdAt: 'asc' },
         });
+        return rows.map(withProjectAndPR);
     }
-    findStaleArchivingWithProject() {
+    async findStaleArchivingWithProject() {
         const staleThreshold = new Date(Date.now() - STALE_ARCHIVING_THRESHOLD_MS);
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 status: 'ARCHIVING',
                 updatedAt: { lt: staleThreshold },
             },
-            include: {
-                project: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
             orderBy: { updatedAt: 'asc' },
         });
+        return rows.map(withProjectAndPR);
     }
-    findByIdWithProject(id) {
-        return prisma.workspace.findUnique({
+    async findByIdWithProject(id) {
+        const row = await prisma.workspace.findUnique({
             where: { id },
-            include: {
-                project: true,
-            },
-        });
-    }
-    findNeedingPRSync(staleThresholdMinutes = 5) {
-        const staleThreshold = new Date(Date.now() - staleThresholdMinutes * 60 * 1000);
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: { not: null },
-                OR: [{ prUpdatedAt: null }, { prUpdatedAt: { lt: staleThreshold } }],
-            },
-            include: {
-                project: true,
-            },
-            orderBy: { prUpdatedAt: 'asc' },
-        });
-    }
-    findNeedingPRDiscovery() {
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: null,
-                branchName: { not: null },
-            },
-            include: {
-                project: true,
-            },
-            orderBy: { updatedAt: 'desc' },
+            include: { project: true, pr: true, autoIteration: true },
         });
+        return row ? withProjectAndPR(row) : null;
     }
     async markHasHadSessions(id) {
         await prisma.workspace.updateMany({
@@ -290,45 +349,55 @@ class WorkspaceAccessor {
             data: { hasHadSessions: true },
         });
     }
-    async recordRatchetSessionEnd(workspaceId, sessionId, outcome) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetActiveSessionId: sessionId },
-            data: { ratchetActiveSessionId: null, ratchetDispatchOutcome: outcome },
-        });
-        return result.count > 0;
+    applyPrSnapshotWithDispatchReset(workspaceId, observation) {
+        return this.applyPrAggregateUpdateWithDispatchReset(workspaceId, observation);
     }
-    async recordRatchetDispatchIfEnabled(workspaceId, dispatch) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true },
-            data: {
-                ratchetActiveSessionId: dispatch.sessionId,
-                ratchetLastCiRunId: dispatch.snapshotKey,
-                ratchetDispatchOutcome: 'RUNNING',
-                ratchetDispatchRetryCount: dispatch.retryCount,
-            },
-        });
-        return result.count > 0;
+    applyPrObservationWithDispatchReset(workspaceId, observation) {
+        const { expectedPrNumber, ...fields } = observation;
+        return this.applyPrAggregateUpdateWithDispatchReset(workspaceId, fields, expectedPrNumber);
     }
-    async adoptRatchetActiveSessionIfEnabled(workspaceId, sessionId) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true },
-            data: { ratchetActiveSessionId: sessionId, ratchetDispatchOutcome: 'RUNNING' },
+    async recordPrSnapshotWithBranchName(workspaceId, branchName, prFields) {
+        await prisma.$transaction(async (transaction) => {
+            await workspacePrAccessor.writeInTransaction(transaction, workspaceId, prFields);
+            await transaction.workspace.update({ where: { id: workspaceId }, data: { branchName } });
         });
-        return result.count > 0;
     }
-    async transitionRatchetStateIfEnabled(workspaceId, fromState, data) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: true, ratchetState: fromState },
-            data,
+    async setBranchNameAndClearDiscoverySchedule(workspaceId, branchName) {
+        await prisma.$transaction(async (transaction) => {
+            await transaction.workspace.update({
+                where: { id: workspaceId },
+                data: { branchName, isAutoGeneratedBranch: false },
+            });
+            await workspacePrAccessor.clearDiscoverySchedule(transaction, workspaceId);
         });
-        return result.count > 0;
     }
-    async settleRatchetIdleWhileDisabled(workspaceId, fromState) {
-        const result = await prisma.workspace.updateMany({
-            where: { id: workspaceId, ratchetEnabled: false, ratchetState: fromState },
-            data: { ratchetState: 'IDLE', ratchetLastCheckedAt: new Date() },
+    async applyPrAggregateUpdateWithDispatchReset(workspaceId, observation, expectedPrNumber) {
+        const { branchName, ...prFields } = observation;
+        return await prisma.$transaction(async (transaction) => {
+            const current = await workspacePrAccessor.readAggregate(transaction, workspaceId);
+            if (!current) {
+                return { applied: false, dispatchReset: false };
+            }
+            if (expectedPrNumber !== undefined &&
+                current.prNumber !== null &&
+                current.prNumber !== expectedPrNumber) {
+                return { applied: false, dispatchReset: false };
+            }
+            const dispatch = await workspaceRatchetAccessor.readDispatchGuard(transaction, workspaceId);
+            const shouldReset = prAggregateChanged(current, observation) &&
+                (dispatch?.dispatchOutcome === 'COMPLETED' || dispatch?.dispatchOutcome === 'DIED');
+            const applied = await workspacePrAccessor.applyAggregateIfUnchanged(transaction, workspaceId, current, prFields);
+            if (!applied) {
+                return { applied: false, dispatchReset: false };
+            }
+            if (branchName !== undefined) {
+                await transaction.workspace.update({ where: { id: workspaceId }, data: { branchName } });
+            }
+            const dispatchReset = shouldReset && dispatch
+                ? await workspaceRatchetAccessor.resetSettledDispatch(transaction, workspaceId, dispatch)
+                : false;
+            return { applied: true, dispatchReset };
         });
-        return result.count > 0;
     }
     async appendInitOutput(id, output, maxSize = 50 * 1024) {
         const truncationMarker = '[...truncated...]\n';
@@ -387,71 +456,17 @@ class WorkspaceAccessor {
             },
         });
     }
-    findByIdsWithProject(ids) {
+    async findByIdsWithProject(ids) {
         if (ids.length === 0) {
-            return Promise.resolve([]);
+            return [];
         }
-        return prisma.workspace.findMany({
+        const rows = await prisma.workspace.findMany({
             where: {
                 id: { in: ids },
             },
-            include: {
-                project: true,
-            },
-        });
-    }
-    findWithPRsForRatchet() {
-        return prisma.workspace.findMany({
-            where: {
-                status: 'READY',
-                prUrl: { not: null },
-                ratchetEnabled: true,
-                ratchetState: { not: 'MERGED' },
-                prState: { not: 'CLOSED' },
-            },
-            select: {
-                id: true,
-                prUrl: true,
-                prNumber: true,
-                prState: true,
-                prCiStatus: true,
-                defaultSessionProvider: true,
-                ratchetSessionProvider: true,
-                ratchetEnabled: true,
-                ratchetState: true,
-                ratchetActiveSessionId: true,
-                ratchetLastCiRunId: true,
-                ratchetDispatchOutcome: true,
-                ratchetDispatchRetryCount: true,
-                prReviewLastCheckedAt: true,
-            },
-            orderBy: { ratchetLastCheckedAt: 'asc' },
-        });
-    }
-    findForRatchetById(id) {
-        return prisma.workspace.findFirst({
-            where: {
-                id,
-                status: 'READY',
-                prUrl: { not: null },
-            },
-            select: {
-                id: true,
-                prUrl: true,
-                prNumber: true,
-                prState: true,
-                prCiStatus: true,
-                defaultSessionProvider: true,
-                ratchetSessionProvider: true,
-                ratchetEnabled: true,
-                ratchetState: true,
-                ratchetActiveSessionId: true,
-                ratchetLastCiRunId: true,
-                ratchetDispatchOutcome: true,
-                ratchetDispatchRetryCount: true,
-                prReviewLastCheckedAt: true,
-            },
+            include: { project: true, pr: true, autoIteration: true },
         });
+        return rows.map(withProjectAndPR);
     }
     findChildrenByParentId(parentId) {
         return prisma.workspace.findMany({
@@ -459,18 +474,20 @@ class WorkspaceAccessor {
             orderBy: { createdAt: 'asc' },
         });
     }
-    findChildrenWithStatus(parentId) {
-        return prisma.workspace.findMany({
+    async findChildrenWithStatus(parentId) {
+        const rows = await prisma.workspace.findMany({
             where: { parentWorkspaceId: parentId, status: { not: 'ARCHIVED' } },
-            include: { agentSessions: true, project: true },
+            include: { agentSessions: true, project: true, ...sideTables },
             orderBy: { createdAt: 'asc' },
         });
+        return rows.map(flatten);
     }
-    findParentWorkspace(childId) {
-        return prisma.workspace.findFirst({
+    async findParentWorkspace(childId) {
+        const row = await prisma.workspace.findFirst({
             where: { childWorkspaces: { some: { id: childId } } },
-            include: { project: true },
+            include: { project: true, pr: true, autoIteration: true },
         });
+        return row ? withProjectAndPR(row) : null;
     }
 }
 export const workspaceAccessor = new WorkspaceAccessor();