factory-factory 0.3.9 → 0.3.11

package/dist/src/backend/domains/ratchet/ratchet.service.js

@@ -1,653 +0,0 @@
-import { EventEmitter } from 'node:events';
-import pLimit from 'p-limit';
-import { workspaceAccessor } from '../../../backend/resource_accessors/workspace.accessor.js';
-import { SERVICE_CONCURRENCY, SERVICE_INTERVAL_MS, SERVICE_TIMEOUT_MS, } from '../../../backend/services/constants.js';
-import { createLogger } from '../../../backend/services/logger.service.js';
-import { RateLimitBackoff } from '../../../backend/services/rate-limit-backoff.js';
-import { CIStatus, RatchetState } from '../../../shared/core/index.js';
-import { getActiveRatchetSession as getActiveRatchetSessionHelper, hasActiveSession as hasActiveSessionHelper, } from './ratchet-active-session.helpers.js';
-import { triggerRatchetFixer } from './ratchet-fixer-dispatch.helpers.js';
-import { buildFailedCheckDiagnostics as buildFailedCheckDiagnosticsHelper, buildReviewTimestampDiagnostics as buildReviewTimestampDiagnosticsHelper, buildSnapshotDiagnostics as buildSnapshotDiagnosticsHelper, computeDispatchSnapshotKey as computeDispatchSnapshotKeyHelper, computeLatestReviewActivityAtMs as computeLatestReviewActivityAtMsHelper, determineRatchetState as determineRatchetStateHelper, fetchPRState as fetchPRStateHelper, getAuthenticatedUsernameCached as getAuthenticatedUsernameCachedHelper, hasNewReviewActivitySinceLastDispatch as hasNewReviewActivitySinceLastDispatchHelper, shouldSkipCleanPR as shouldSkipCleanPRHelper, } from './ratchet-pr-state.helpers.js';
-import { handleReviewCommentPoll as handleReviewCommentPollHelper } from './ratchet-review-poll.helpers.js';
-const logger = createLogger('ratchet');
-export const RATCHET_STATE_CHANGED = 'ratchet_state_changed';
-export const RATCHET_TOGGLED = 'ratchet_toggled';
-class RatchetService extends EventEmitter {
-    isShuttingDown = false;
-    monitorLoop = null;
-    sleepTimeout = null;
-    sleepResolve = null;
-    workspaceCheckTimeoutMs = SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck;
-    checkLimit = pLimit(SERVICE_CONCURRENCY.ratchetWorkspaceChecks);
-    inFlightWorkspaceChecks = new Map();
-    cachedAuthenticatedUsername = null;
-    backoff = new RateLimitBackoff();
-    reviewPollTrackers = new Map();
-    sessionBridge = null;
-    githubBridge = null;
-    snapshotBridge = null;
-    configure(bridges) {
-        this.sessionBridge = bridges.session;
-        this.githubBridge = bridges.github;
-        this.snapshotBridge = bridges.snapshot;
-    }
-    get session() {
-        if (!this.sessionBridge) {
-            throw new Error('RatchetService not configured: session bridge missing. Call configure() first.');
-        }
-        return this.sessionBridge;
-    }
-    get github() {
-        if (!this.githubBridge) {
-            throw new Error('RatchetService not configured: github bridge missing. Call configure() first.');
-        }
-        return this.githubBridge;
-    }
-    get snapshot() {
-        if (!this.snapshotBridge) {
-            throw new Error('RatchetService not configured: snapshot bridge missing. Call configure() first.');
-        }
-        return this.snapshotBridge;
-    }
-    start() {
-        if (this.monitorLoop !== null) {
-            return;
-        }
-        this.isShuttingDown = false;
-        this.monitorLoop = this.runContinuousLoop();
-        logger.info('Ratchet service started', { intervalMs: SERVICE_INTERVAL_MS.ratchetPoll });
-    }
-    async stop() {
-        this.isShuttingDown = true;
-        this.wakeSleep();
-        if (this.monitorLoop !== null) {
-            logger.debug('Waiting for ratchet monitor loop to complete');
-            await this.monitorLoop;
-            this.monitorLoop = null;
-        }
-        logger.info('Ratchet service stopped');
-    }
-    async runContinuousLoop() {
-        while (!this.isShuttingDown) {
-            try {
-                this.backoff.beginCycle();
-                await this.checkAllWorkspaces();
-                this.backoff.resetIfCleanCycle(logger, 'Ratchet');
-            }
-            catch (err) {
-                logger.error('Ratchet check failed', err);
-            }
-            if (!this.isShuttingDown) {
-                const delayMs = this.backoff.computeDelay(SERVICE_INTERVAL_MS.ratchetPoll);
-                if (this.backoff.currentMultiplier > 1) {
-                    logger.debug('Using backoff delay for next ratchet check', {
-                        baseIntervalMs: SERVICE_INTERVAL_MS.ratchetPoll,
-                        backoffMultiplier: this.backoff.currentMultiplier,
-                        delayMs,
-                    });
-                }
-                await this.sleep(delayMs);
-            }
-        }
-    }
-    sleep(ms) {
-        return new Promise((resolve) => {
-            let settled = false;
-            const finish = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                if (this.sleepTimeout) {
-                    clearTimeout(this.sleepTimeout);
-                    this.sleepTimeout = null;
-                }
-                if (this.sleepResolve === finish) {
-                    this.sleepResolve = null;
-                }
-                resolve();
-            };
-            this.sleepResolve = finish;
-            this.sleepTimeout = setTimeout(finish, ms);
-            if (this.isShuttingDown) {
-                finish();
-            }
-        });
-    }
-    wakeSleep() {
-        const resolveSleep = this.sleepResolve;
-        if (resolveSleep) {
-            resolveSleep();
-        }
-    }
-    async checkAllWorkspaces() {
-        if (this.isShuttingDown) {
-            return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
-        }
-        const workspaces = await workspaceAccessor.findWithPRsForRatchet();
-        if (workspaces.length === 0) {
-            return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
-        }
-        const results = await Promise.all(workspaces.map((workspace) => this.checkLimit(() => this.runWorkspaceCheckSafely(workspace))));
-        const stateChanges = results.filter((r) => r.previousState !== r.newState).length;
-        const actionsTriggered = results.filter((r) => r.action.type === 'TRIGGERED_FIXER').length;
-        if (stateChanges > 0 || actionsTriggered > 0) {
-            logger.info('Ratchet check completed', {
-                checked: workspaces.length,
-                stateChanges,
-                actionsTriggered,
-            });
-        }
-        return { checked: workspaces.length, stateChanges, actionsTriggered, results };
-    }
-    async checkWorkspaceById(workspaceId) {
-        if (this.isShuttingDown) {
-            return null;
-        }
-        const workspace = await workspaceAccessor.findForRatchetById(workspaceId);
-        if (!workspace) {
-            return null;
-        }
-        return this.runWorkspaceCheckSafely(workspace);
-    }
-    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
-        await workspaceAccessor.clearRatchetActiveSession(workspaceId, sessionId);
-    }
-    async runWorkspaceCheckSafely(workspace) {
-        const checkPromise = this.runWorkspaceCheck(workspace.id, () => this.processWorkspace(workspace));
-        try {
-            return await this.withWorkspaceCheckTimeout(workspace, checkPromise);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.warn('Ratchet workspace check failed', {
-                workspaceId: workspace.id,
-                prUrl: workspace.prUrl,
-                error: errorMessage,
-            });
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action: { type: 'ERROR', error: errorMessage },
-            };
-        }
-    }
-    withWorkspaceCheckTimeout(workspace, checkPromise) {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                if (this.inFlightWorkspaceChecks.get(workspace.id) === checkPromise) {
-                    this.inFlightWorkspaceChecks.delete(workspace.id);
-                }
-                reject(new Error(`Workspace check timed out after ${this.workspaceCheckTimeoutMs}ms`));
-            }, this.workspaceCheckTimeoutMs);
-            timeout.unref?.();
-            checkPromise.then(resolve, reject).finally(() => {
-                clearTimeout(timeout);
-            });
-        });
-    }
-    runWorkspaceCheck(workspaceId, runner) {
-        const existing = this.inFlightWorkspaceChecks.get(workspaceId);
-        if (existing) {
-            return existing;
-        }
-        const inFlight = runner().finally(() => {
-            if (this.inFlightWorkspaceChecks.get(workspaceId) === inFlight) {
-                this.inFlightWorkspaceChecks.delete(workspaceId);
-            }
-        });
-        this.inFlightWorkspaceChecks.set(workspaceId, inFlight);
-        return inFlight;
-    }
-    async setWorkspaceRatcheting(workspaceId, enabled) {
-        const workspace = await workspaceAccessor.findById(workspaceId);
-        if (!workspace) {
-            throw new Error(`Workspace not found: ${workspaceId}`);
-        }
-        if (enabled) {
-            await workspaceAccessor.update(workspaceId, {
-                ratchetEnabled: true,
-            });
-            this.emit(RATCHET_TOGGLED, {
-                workspaceId,
-                enabled: true,
-                ratchetState: workspace.ratchetState,
-            });
-            return;
-        }
-        const activeSessionId = workspace.ratchetActiveSessionId;
-        if (activeSessionId && this.session.isSessionRunning(activeSessionId)) {
-            try {
-                await this.session.stopSession(activeSessionId);
-            }
-            catch (error) {
-                logger.warn('Failed to stop active ratchet session while disabling ratchet', {
-                    workspaceId,
-                    sessionId: activeSessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        await workspaceAccessor.update(workspaceId, {
-            ratchetEnabled: false,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
-        });
-        if (workspace.ratchetState !== RatchetState.IDLE) {
-            this.emit(RATCHET_STATE_CHANGED, {
-                workspaceId,
-                fromState: workspace.ratchetState,
-                toState: RatchetState.IDLE,
-            });
-        }
-        this.emit(RATCHET_TOGGLED, {
-            workspaceId,
-            enabled: false,
-            ratchetState: RatchetState.IDLE,
-        });
-    }
-    async processWorkspace(workspace) {
-        if (this.isShuttingDown) {
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action: { type: 'WAITING', reason: 'Shutting down' },
-            };
-        }
-        if (!workspace.ratchetEnabled) {
-            const action = { type: 'DISABLED', reason: 'Workspace ratcheting disabled' };
-            const newState = RatchetState.IDLE;
-            await workspaceAccessor.update(workspace.id, {
-                ratchetState: newState,
-                ratchetLastCheckedAt: new Date(),
-            });
-            if (workspace.ratchetState !== newState) {
-                this.emit(RATCHET_STATE_CHANGED, {
-                    workspaceId: workspace.id,
-                    fromState: workspace.ratchetState,
-                    toState: newState,
-                });
-            }
-            this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, newState, action, null);
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState,
-                action,
-            };
-        }
-        try {
-            const authenticatedUsername = await this.getAuthenticatedUsernameCached();
-            const prStateInfo = await this.fetchPRState(workspace, authenticatedUsername);
-            if (!prStateInfo) {
-                const action = { type: 'ERROR', error: 'Failed to fetch PR state' };
-                this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
-                return {
-                    workspaceId: workspace.id,
-                    previousState: workspace.ratchetState,
-                    newState: workspace.ratchetState,
-                    action,
-                };
-            }
-            const decisionContext = await this.buildRatchetDecisionContext(workspace, prStateInfo);
-            const decision = this.decideRatchetAction(decisionContext);
-            if (prStateInfo.prState === 'MERGED') {
-                this.reviewPollTrackers.delete(workspace.id);
-            }
-            else if (decisionContext.isCleanPrWithNoNewReviewActivity) {
-                const pollDispatch = await this.processReviewCommentPoll(workspace, prStateInfo, authenticatedUsername);
-                if (pollDispatch) {
-                    return pollDispatch;
-                }
-            }
-            else {
-                this.reviewPollTrackers.delete(workspace.id);
-            }
-            const action = await this.applyRatchetDecision(decisionContext, decision);
-            await this.updateWorkspaceAfterCheck(workspace, prStateInfo, action, decisionContext.finalState);
-            if (decisionContext.previousState !== decisionContext.finalState) {
-                this.emit(RATCHET_STATE_CHANGED, {
-                    workspaceId: workspace.id,
-                    fromState: decisionContext.previousState,
-                    toState: decisionContext.finalState,
-                });
-            }
-            this.logWorkspaceRatchetingDecision(workspace, decisionContext.previousState, decisionContext.finalState, action, prStateInfo, decisionContext);
-            return {
-                workspaceId: workspace.id,
-                previousState: decisionContext.previousState,
-                newState: decisionContext.finalState,
-                action,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Error processing workspace in ratchet', error, {
-                workspaceId: workspace.id,
-            });
-            const action = { type: 'ERROR', error: errorMessage };
-            this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action,
-            };
-        }
-    }
-    logWorkspaceRatchetingDecision(workspace, previousState, newState, action, prStateInfo, decisionContext = null) {
-        const prNumber = prStateInfo?.prNumber ?? workspace.prNumber;
-        const prNumberLabel = prNumber ?? 'unknown';
-        const workspacePrPrefix = `workspace ${workspace.id} for PR #${prNumberLabel}`;
-        const context = this.buildRatchetingLogContext(workspace, previousState, newState, action, prStateInfo, prNumber, decisionContext);
-        if (action.type === 'TRIGGERED_FIXER') {
-            logger.info(`Ratcheting ${workspacePrPrefix}`, {
-                ...context,
-                sessionId: action.sessionId,
-                promptSent: action.promptSent,
-            });
-            return;
-        }
-        const reason = this.describeNonRatchetingReason(action);
-        logger.info(`Not ratcheting ${workspacePrPrefix} because ${reason}`, context);
-    }
-    buildRatchetingLogContext(workspace, previousState, newState, action, prStateInfo, prNumber, decisionContext) {
-        const reviewDiagnostics = this.buildReviewTimestampDiagnostics(workspace, prStateInfo, decisionContext);
-        const snapshotDiagnostics = this.buildSnapshotDiagnostics(workspace, prStateInfo, decisionContext);
-        const latestReviewActivityAt = reviewDiagnostics.latestReviewActivityAtMs;
-        return {
-            workspaceId: workspace.id,
-            prUrl: workspace.prUrl,
-            prNumber,
-            prState: prStateInfo?.prState ?? null,
-            ciStatus: prStateInfo?.ciStatus ?? null,
-            hasChangesRequested: prStateInfo?.hasChangesRequested ?? null,
-            snapshotKey: prStateInfo?.snapshotKey ?? null,
-            ciSnapshotKey: snapshotDiagnostics.ciSnapshotKey,
-            snapshotComparison: snapshotDiagnostics.snapshotComparison,
-            previousState,
-            newState,
-            ratchetEnabled: workspace.ratchetEnabled,
-            ratchetActiveSessionId: workspace.ratchetActiveSessionId,
-            ratchetLastCiRunId: workspace.ratchetLastCiRunId,
-            ciStatusCheckRollup: prStateInfo?.statusCheckRollup ?? null,
-            ciFailedChecks: this.buildFailedCheckDiagnostics(prStateInfo),
-            prReviewLastCheckedAt: workspace.prReviewLastCheckedAt?.toISOString() ?? null,
-            latestReviewActivityAt: latestReviewActivityAt
-                ? new Date(latestReviewActivityAt).toISOString()
-                : null,
-            reviewTimestampComparison: reviewDiagnostics.reviewTimestampComparison,
-            actionType: action.type,
-        };
-    }
-    buildSnapshotDiagnostics(workspace, prStateInfo, decisionContext) {
-        return buildSnapshotDiagnosticsHelper(workspace, prStateInfo, decisionContext);
-    }
-    buildReviewTimestampDiagnostics(workspace, prStateInfo, decisionContext) {
-        return buildReviewTimestampDiagnosticsHelper(workspace, prStateInfo, decisionContext, logger);
-    }
-    buildFailedCheckDiagnostics(prStateInfo) {
-        return buildFailedCheckDiagnosticsHelper(prStateInfo);
-    }
-    describeNonRatchetingReason(action) {
-        switch (action.type) {
-            case 'WAITING':
-                return action.reason;
-            case 'FIXER_ACTIVE':
-                return `Ratchet fixer session is already active (${action.sessionId})`;
-            case 'DISABLED':
-                return action.reason;
-            case 'COMPLETED':
-                return 'PR is already merged';
-            case 'ERROR':
-                return action.error;
-        }
-        const exhaustiveCheck = action;
-        throw new Error(`Unhandled ratchet action: ${JSON.stringify(exhaustiveCheck)}`);
-    }
-    async buildRatchetDecisionContext(workspace, prStateInfo) {
-        const previousState = workspace.ratchetState;
-        const newState = this.determineRatchetState(prStateInfo);
-        const finalState = workspace.ratchetEnabled ? newState : RatchetState.IDLE;
-        const hasNewReviewActivitySinceLastDispatch = this.hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo);
-        const hasStateChangedSinceLastDispatch = this.hasStateChangedSinceLastDispatch(workspace, prStateInfo);
-        const isCleanPrWithNoNewReviewActivity = this.shouldSkipCleanPR(workspace, prStateInfo);
-        const activityChecks = await this.collectRatchetingActivityChecks(workspace, prStateInfo, isCleanPrWithNoNewReviewActivity, hasStateChangedSinceLastDispatch);
-        return {
-            workspace,
-            prStateInfo,
-            previousState,
-            newState,
-            finalState,
-            hasNewReviewActivitySinceLastDispatch,
-            hasStateChangedSinceLastDispatch,
-            isCleanPrWithNoNewReviewActivity,
-            activeRatchetSession: activityChecks.activeRatchetSession,
-            hasOtherActiveSession: activityChecks.hasOtherActiveSession,
-        };
-    }
-    async collectRatchetingActivityChecks(workspace, prStateInfo, isCleanPrWithNoNewReviewActivity, hasStateChangedSinceLastDispatch) {
-        if (!workspace.ratchetEnabled ||
-            prStateInfo.prState !== 'OPEN' ||
-            isCleanPrWithNoNewReviewActivity) {
-            return {
-                activeRatchetSession: null,
-                hasOtherActiveSession: false,
-            };
-        }
-        const activeRatchetSession = await this.getActiveRatchetSession(workspace);
-        if (activeRatchetSession) {
-            return {
-                activeRatchetSession,
-                hasOtherActiveSession: false,
-            };
-        }
-        if (!hasStateChangedSinceLastDispatch) {
-            return {
-                activeRatchetSession: null,
-                hasOtherActiveSession: false,
-            };
-        }
-        return {
-            activeRatchetSession: null,
-            hasOtherActiveSession: await this.hasActiveSession(workspace.id),
-        };
-    }
-    decideRatchetAction(context) {
-        if (!context.workspace.ratchetEnabled) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
-            };
-        }
-        if (context.prStateInfo.prState === 'MERGED') {
-            return { type: 'RETURN_ACTION', action: { type: 'COMPLETED' } };
-        }
-        if (context.prStateInfo.prState !== 'OPEN') {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR is not open' },
-            };
-        }
-        const isTerminalCIStatus = context.prStateInfo.ciStatus === CIStatus.SUCCESS ||
-            context.prStateInfo.ciStatus === CIStatus.FAILURE;
-        if (!isTerminalCIStatus) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
-            };
-        }
-        if (context.isCleanPrWithNoNewReviewActivity) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR is clean (green CI and no new review activity)' },
-            };
-        }
-        if (!this.hasActionableFixTrigger(context.prStateInfo)) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'No CI failures or PR review comments to address' },
-            };
-        }
-        if (context.activeRatchetSession) {
-            return { type: 'RETURN_ACTION', action: context.activeRatchetSession };
-        }
-        if (!context.hasStateChangedSinceLastDispatch) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR state unchanged since last ratchet dispatch' },
-            };
-        }
-        if (context.hasOtherActiveSession) {
-            return {
-                type: 'RETURN_ACTION',
-                action: {
-                    type: 'WAITING',
-                    reason: 'Workspace is not idle (active session)',
-                },
-            };
-        }
-        return { type: 'TRIGGER_FIXER' };
-    }
-    async applyRatchetDecision(context, decision) {
-        if (decision.type === 'RETURN_ACTION') {
-            return decision.action;
-        }
-        return await this.triggerFixer(context.workspace, context.prStateInfo);
-    }
-    hasActionableFixTrigger(prStateInfo) {
-        if (prStateInfo.ciStatus === CIStatus.FAILURE) {
-            return true;
-        }
-        return (prStateInfo.reviewComments?.length ?? 0) > 0;
-    }
-    shouldSkipCleanPR(workspace, prStateInfo) {
-        return shouldSkipCleanPRHelper(workspace, prStateInfo, logger);
-    }
-    hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo) {
-        return hasNewReviewActivitySinceLastDispatchHelper(workspace, prStateInfo, logger);
-    }
-    async processReviewCommentPoll(workspace, prStateInfo, authenticatedUsername) {
-        const pollResult = await this.handleReviewCommentPoll(workspace, prStateInfo, authenticatedUsername);
-        if (pollResult.action !== 'comments-found') {
-            return null;
-        }
-        const freshContext = await this.buildRatchetDecisionContext(workspace, pollResult.freshPrState);
-        const freshDecision = this.decideRatchetAction(freshContext);
-        const freshAction = await this.applyRatchetDecision(freshContext, freshDecision);
-        await this.updateWorkspaceAfterCheck(workspace, pollResult.freshPrState, freshAction, freshContext.finalState);
-        if (freshContext.previousState !== freshContext.finalState) {
-            this.emit(RATCHET_STATE_CHANGED, {
-                workspaceId: workspace.id,
-                fromState: freshContext.previousState,
-                toState: freshContext.finalState,
-            });
-        }
-        this.logWorkspaceRatchetingDecision(workspace, freshContext.previousState, freshContext.finalState, freshAction, pollResult.freshPrState, freshContext);
-        return {
-            workspaceId: workspace.id,
-            previousState: freshContext.previousState,
-            newState: freshContext.finalState,
-            action: freshAction,
-        };
-    }
-    async handleReviewCommentPoll(workspace, prStateInfo, authenticatedUsername) {
-        return await handleReviewCommentPollHelper({
-            workspace,
-            prStateInfo,
-            authenticatedUsername,
-            reviewPollTrackers: this.reviewPollTrackers,
-            isShuttingDown: this.isShuttingDown,
-            fetchPRState: (workspaceArg, authenticatedUsernameArg) => this.fetchPRState(workspaceArg, authenticatedUsernameArg),
-            shouldSkipCleanPR: (workspaceArg, prStateInfoArg) => this.shouldSkipCleanPR(workspaceArg, prStateInfoArg),
-            logger,
-        });
-    }
-    hasStateChangedSinceLastDispatch(workspace, prStateInfo) {
-        return workspace.ratchetLastCiRunId !== prStateInfo.snapshotKey;
-    }
-    async updateWorkspaceAfterCheck(workspace, prStateInfo, action, nextState) {
-        const now = new Date();
-        const dispatched = action.type === 'TRIGGERED_FIXER' && action.promptSent;
-        await workspaceAccessor.update(workspace.id, {
-            ratchetState: nextState,
-            ratchetLastCheckedAt: now,
-            ...(dispatched
-                ? {
-                    ratchetLastCiRunId: prStateInfo.snapshotKey,
-                }
-                : {}),
-        });
-        if (dispatched) {
-            await this.snapshot.recordReviewCheck(workspace.id, now);
-        }
-    }
-    async getActiveRatchetSession(workspace) {
-        return await getActiveRatchetSessionHelper({
-            workspace,
-            sessionBridge: this.session,
-            snapshotBridge: this.snapshot,
-            resetDispatchState: (workspaceId) => this.resetDispatchState(workspaceId),
-            clearActiveSession: (workspaceId) => this.clearActiveSession(workspaceId),
-            logger,
-        });
-    }
-    async hasActiveSession(workspaceId) {
-        return await hasActiveSessionHelper(workspaceId, this.session);
-    }
-    async fetchPRState(workspace, authenticatedUsername) {
-        return await fetchPRStateHelper({
-            workspace,
-            authenticatedUsername,
-            github: this.github,
-            backoff: this.backoff,
-            logger,
-            computeLatestReviewActivityAtMs: (prDetails, reviewComments, authenticatedUsernameArg) => this.computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsernameArg),
-            computeDispatchSnapshotKey: (ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) => this.computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks),
-        });
-    }
-    computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) {
-        return computeDispatchSnapshotKeyHelper(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks);
-    }
-    computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername) {
-        return computeLatestReviewActivityAtMsHelper(prDetails, reviewComments, authenticatedUsername);
-    }
-    async getAuthenticatedUsernameCached() {
-        const { username, cache } = await getAuthenticatedUsernameCachedHelper({
-            cachedValue: this.cachedAuthenticatedUsername,
-            github: this.github,
-        });
-        this.cachedAuthenticatedUsername = cache;
-        return username;
-    }
-    determineRatchetState(pr) {
-        return determineRatchetStateHelper(pr);
-    }
-    async triggerFixer(workspace, prStateInfo) {
-        return await triggerRatchetFixer({
-            workspace,
-            prStateInfo,
-            sessionBridge: this.session,
-            setActiveSession: (workspaceId, sessionId) => this.setActiveSession(workspaceId, sessionId),
-            clearActiveSession: (workspaceId) => this.clearActiveSession(workspaceId),
-            logger,
-        });
-    }
-    async setActiveSession(workspaceId, sessionId) {
-        await workspaceAccessor.update(workspaceId, { ratchetActiveSessionId: sessionId });
-    }
-    async clearActiveSession(workspaceId) {
-        await workspaceAccessor.update(workspaceId, { ratchetActiveSessionId: null });
-    }
-    async resetDispatchState(workspaceId) {
-        await workspaceAccessor.update(workspaceId, {
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
-        });
-    }
-}
-export const ratchetService = new RatchetService();
-//# sourceMappingURL=ratchet.service.js.map