@xfey/tutti 0.1.0

package/dist/run-pipeline/openai.js

@@ -0,0 +1,548 @@
+import { join } from "node:path";
+import { createNodeNpmCheckPlan, executeCheckPlan } from "../checks/index.js";
+import { candidateChangedAfterChecks } from "./candidate-diff.js";
+import { checkSkipFields, checkStatus, checksSummary, completedWithoutRepoChanges, docsStatusForChangedPaths, failedBeforeChecks, failedFinishedResult, promotionNotAttempted, promotionNotPromoted, successfulRunSummary, } from "./result-projections.js";
+import { runPromotionReconcile } from "./promotion-reconcile.js";
+import { runWorkspaceWriteTask } from "./task-run-invocation.js";
+import { readOpenAiApiKeyCredential } from "../providers/openai/credential-store.js";
+import { resolveOpenAiProviderConfig, } from "../providers/openai/provider-config.js";
+import { CodexAppServerWorkspaceWriteRunError } from "../providers/openai/app-server/workspace-write-run.js";
+import { cleanupRunWorkspace, collectRunDiff, createResultCommit, prepareRunWorkspace, promoteRunResult, WorkspaceOpsError, } from "../workspace-ops/index.js";
+export { TASK_RUN_OUTPUT_SCHEMA } from "./task-run-output.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function summarizeProviderError(error) {
+    const diagnosticParts = [
+        error.details.turn_error_code === undefined
+            ? ""
+            : `provider_code=${error.details.turn_error_code}`,
+        error.details.turn_error_http_status === undefined
+            ? ""
+            : `http_status=${error.details.turn_error_http_status}`,
+        error.details.stderr_excerpt === undefined || error.details.stderr_excerpt.trim() === ""
+            ? ""
+            : `stderr=${error.details.stderr_excerpt}`,
+    ].filter((part) => part !== "");
+    const summary = diagnosticParts.length === 0
+        ? error.message
+        : `${error.message} (${diagnosticParts.join("; ")})`;
+    const looksLikeSchemaError = summary.includes("invalid_json_schema") ||
+        summary.includes("Invalid schema") ||
+        summary.includes("response_format");
+    return failedBeforeChecks({
+        summary,
+        errorCode: looksLikeSchemaError
+            ? "codex_app_server_output_schema_invalid"
+            : `codex_app_server_${error.code}`,
+        retryable: !looksLikeSchemaError &&
+            (error.code === "app_server_protocol_error" ||
+                error.code === "turn_timeout" ||
+                error.code === "turn_failed" ||
+                error.code === "thread_start_failed"),
+    });
+}
+function summarizeWorkspaceOpsError(error, changedPaths) {
+    return failedBeforeChecks({
+        summary: error.message,
+        errorCode: `workspace_ops_${error.code}`,
+        retryable: error.code === "conflict",
+        ...(changedPaths === undefined ? {} : { changedPaths }),
+        promotion: error.code === "conflict"
+            ? promotionNotPromoted("mainline_not_promotable", error.message)
+            : promotionNotAttempted("workspace_ops_failed", error.message),
+    });
+}
+function isMainlineMovedPromotionConflict(error) {
+    return (error instanceof WorkspaceOpsError &&
+        error.code === "conflict" &&
+        isRecord(error.details) &&
+        error.details.reason_code === "mainline_not_at_base");
+}
+function runLineageFields(input) {
+    return {
+        run_lineage_kind: input.run_lineage.kind,
+        run_lineage_attempt: input.run_lineage.attempt,
+        ...(input.run_lineage.kind !== "initial"
+            ? {
+                parent_activity_ref: input.run_lineage.parent_activity_ref,
+                root_activity_ref: input.run_lineage.root_activity_ref,
+            }
+            : {}),
+    };
+}
+function runPipelineFields(input) {
+    return {
+        activity_ref: input.activity_ref,
+        task_id: input.task.id,
+        trigger: input.dispatch_context.trigger,
+        ...runLineageFields(input),
+    };
+}
+function logRunPipelineStage(options, input, fields, message) {
+    options.logger?.info({
+        ...runPipelineFields(input),
+        ...fields,
+    }, message);
+}
+function stageProgressSummary(stage) {
+    switch (stage) {
+        case "run_workspace_prepare":
+            return "preparing an isolated run workspace.";
+        case "provider_task_run":
+            return "running Codex task implementation.";
+        case "provider_retry":
+            return "retrying Codex task after a transient provider failure.";
+        case "candidate_diff_collect":
+            return "collecting candidate changes.";
+        case "checks":
+            return "running project checks.";
+        case "post_checks_diff_collect":
+            return "rechecking candidate changes after checks.";
+        case "result_commit":
+            return "creating the candidate result commit.";
+        case "promotion":
+            return "promoting candidate changes to mainline.";
+        case "promotion_reconcile":
+            return "reconciling promotion after mainline changed.";
+        case "self_correction":
+            return "retrying task implementation after pipeline feedback.";
+        case "run_workspace_cleanup":
+            return "cleaning up the run workspace.";
+        default:
+            return `running stage ${stage}.`;
+    }
+}
+function reportRunPipelineStageStarted(input, stage) {
+    input.on_stage?.({
+        stage,
+        summary: stageProgressSummary(stage),
+    });
+}
+function stageErrorFields(error) {
+    return {
+        error_name: error instanceof Error ? error.name : "NonError",
+        ...(isRecord(error) && typeof error.code === "string" ? { error_code: error.code } : {}),
+    };
+}
+function elapsedMs(startedAt) {
+    return Math.max(0, Date.now() - startedAt);
+}
+async function loggedAsyncStage(options, input, stage, run, completedFields = () => ({})) {
+    const startedAt = Date.now();
+    reportRunPipelineStageStarted(input, stage);
+    logRunPipelineStage(options, input, { stage }, "Run pipeline stage started");
+    try {
+        const result = await run();
+        logRunPipelineStage(options, input, {
+            stage,
+            duration_ms: elapsedMs(startedAt),
+            ...completedFields(result),
+        }, "Run pipeline stage completed");
+        return result;
+    }
+    catch (error) {
+        logRunPipelineStage(options, input, {
+            stage,
+            duration_ms: elapsedMs(startedAt),
+            ...stageErrorFields(error),
+        }, "Run pipeline stage failed");
+        throw error;
+    }
+}
+function loggedSyncStage(options, input, stage, run, completedFields = () => ({})) {
+    const startedAt = Date.now();
+    reportRunPipelineStageStarted(input, stage);
+    logRunPipelineStage(options, input, { stage }, "Run pipeline stage started");
+    try {
+        const result = run();
+        logRunPipelineStage(options, input, {
+            stage,
+            duration_ms: elapsedMs(startedAt),
+            ...completedFields(result),
+        }, "Run pipeline stage completed");
+        return result;
+    }
+    catch (error) {
+        logRunPipelineStage(options, input, {
+            stage,
+            duration_ms: elapsedMs(startedAt),
+            ...stageErrorFields(error),
+        }, "Run pipeline stage failed");
+        throw error;
+    }
+}
+function runResultLogFields(result) {
+    if (result.result_kind === "finished") {
+        return {
+            result_kind: result.result_kind,
+            outcome: result.outcome,
+            checks: result.checks,
+            docs: result.docs,
+            changed_path_count: result.changed_paths?.length ?? 0,
+            promotion_status: result.promotion?.status,
+        };
+    }
+    if (result.result_kind === "failed") {
+        return {
+            result_kind: result.result_kind,
+            error_code: result.error_code,
+            retryable: result.retryable,
+            changed_path_count: result.changed_paths?.length ?? 0,
+            promotion_status: result.promotion?.status,
+        };
+    }
+    return {
+        result_kind: result.result_kind,
+        changed_path_count: result.changed_paths?.length ?? 0,
+    };
+}
+const MAX_SELF_CORRECTION_RETRIES = 1;
+const MAX_PROVIDER_TRANSIENT_RETRIES = 1;
+function runPipelineResultPromotion(result) {
+    return "promotion" in result ? result.promotion : undefined;
+}
+function buildCorrectionContext(input) {
+    const correction = {
+        summary: input.result.summary,
+        reason_code: input.reasonCode,
+        guidance: input.guidance,
+    };
+    const promotion = runPipelineResultPromotion(input.result);
+    if (promotion?.status === "not_promoted") {
+        correction.promotion_failure = {
+            reason_code: promotion.reason_code ?? input.reasonCode,
+            summary: promotion.summary ?? input.result.summary,
+        };
+    }
+    return correction;
+}
+function requestSelfCorrection(input) {
+    return {
+        request_kind: "self_correction",
+        fallback: input.result,
+        correction_context: buildCorrectionContext(input),
+    };
+}
+function selfCorrectionInput(input, nextAttempt, correctionContext) {
+    return {
+        ...input,
+        run_lineage: {
+            kind: "retry",
+            attempt: nextAttempt,
+            parent_activity_ref: input.activity_ref,
+            root_activity_ref: input.run_lineage.root_activity_ref ?? input.activity_ref,
+        },
+        correction_context: correctionContext,
+    };
+}
+function providerTransientRetryInput(input) {
+    return {
+        ...input,
+        run_lineage: {
+            ...input.run_lineage,
+            attempt: input.run_lineage.attempt + 1,
+        },
+    };
+}
+function appendSelfCorrectionExhaustedSummary(input) {
+    if (input.attemptedRetries <= 0) {
+        return input.result;
+    }
+    return {
+        ...input.result,
+        summary: `${input.result.summary} Self-correction retry limit reached after ${input.attemptedRetries} retry attempt${input.attemptedRetries === 1 ? "" : "s"}.`,
+    };
+}
+function resultTimelineEvents(result) {
+    return result.timeline_events ?? [];
+}
+function withCarriedTimelineEvents(result, carriedTimelineEvents) {
+    if (carriedTimelineEvents.length === 0) {
+        return result;
+    }
+    return {
+        ...result,
+        timeline_events: [...carriedTimelineEvents, ...resultTimelineEvents(result)],
+    };
+}
+function isSelfCorrectionRequest(result) {
+    return "request_kind" in result && result.request_kind === "self_correction";
+}
+function isProviderTransientRunFailure(result) {
+    return (!isSelfCorrectionRequest(result) &&
+        result.result_kind === "failed" &&
+        result.retryable &&
+        result.error_code.startsWith("codex_app_server_"));
+}
+function reconcileSelfCorrectionReason(result) {
+    const promotion = runPipelineResultPromotion(result);
+    if (promotion?.status !== "not_promoted") {
+        return undefined;
+    }
+    if (promotion.reason_code !== undefined) {
+        return promotion.reason_code;
+    }
+    if (result.result_kind === "failed") {
+        return result.error_code;
+    }
+    if (result.result_kind === "finished" && result.outcome === "failed") {
+        return "promotion_reconcile_failed";
+    }
+    return undefined;
+}
+async function runTaskAttempt(options, input) {
+    let handle;
+    let changedPaths;
+    try {
+        const runHandle = loggedSyncStage(options, input, "run_workspace_prepare", () => prepareRunWorkspace({
+            workspaceRoot: options.workspaceRoot,
+            runWorkspaceRoot: options.runWorkspaceRoot,
+            taskId: input.task.id,
+            activityRef: input.activity_ref,
+        }));
+        handle = runHandle;
+        const taskOutput = await loggedAsyncStage(options, input, "provider_task_run", () => runWorkspaceWriteTask(options, input, runHandle), (output) => ({ decision: output.decision }));
+        const diff = loggedSyncStage(options, input, "candidate_diff_collect", () => collectRunDiff(runHandle), (result) => ({ changed_path_count: result.changed_paths.length }));
+        changedPaths = diff.changed_paths;
+        if (taskOutput.decision === "needs_human") {
+            logRunPipelineStage(options, input, {
+                stage: "provider_task_run",
+                decision: taskOutput.decision,
+                changed_path_count: changedPaths.length,
+            }, "Run pipeline needs human input");
+            return {
+                result_kind: "needs_human",
+                summary: taskOutput.summary,
+                clarification_request_payload: taskOutput.clarification_request_payload,
+                changed_paths: changedPaths,
+            };
+        }
+        if (taskOutput.decision === "failed") {
+            const errorCode = "codex_task_failed";
+            return failedBeforeChecks({
+                summary: taskOutput.summary,
+                errorCode,
+                retryable: false,
+                changedPaths,
+                promotion: promotionNotAttempted(errorCode, taskOutput.summary),
+            });
+        }
+        if (changedPaths.length === 0 && taskOutput.decision === "completed_no_repo_changes") {
+            return completedWithoutRepoChanges({
+                summary: taskOutput.summary,
+            });
+        }
+        if (changedPaths.length === 0) {
+            const result = failedBeforeChecks({
+                summary: "Codex completed the Run but produced no candidate changes.",
+                errorCode: "no_candidate_changes",
+                retryable: false,
+                changedPaths,
+                promotion: promotionNotAttempted("no_candidate_changes", "No candidate changes were available for promotion."),
+            });
+            return requestSelfCorrection({
+                result,
+                reasonCode: "no_candidate_changes",
+                guidance: "Produce a concrete candidate diff for the frozen task contract.",
+            });
+        }
+        let docs = docsStatusForChangedPaths(changedPaths);
+        const checkPlan = createNodeNpmCheckPlan({ workspaceRoot: runHandle.repo_root });
+        const checks = await loggedAsyncStage(options, input, "checks", () => executeCheckPlan({
+            workspaceRoot: runHandle.repo_root,
+            plan: checkPlan,
+            ...(options.checkTimeoutMs === undefined ? {} : { timeoutMs: options.checkTimeoutMs }),
+        }), (result) => ({ checks_status: result.status, command_count: result.commands.length }));
+        if (checks.status === "failed") {
+            const result = failedFinishedResult({
+                summary: checksSummary(checks),
+                checks,
+                docs,
+                changedPaths,
+                promotion: promotionNotAttempted("checks_failed", "Local checks failed, so promotion was not attempted."),
+            });
+            return requestSelfCorrection({
+                result,
+                reasonCode: "checks_failed",
+                guidance: "Use the failed checks summary to fix the candidate so the task can pass Tutti checks.",
+            });
+        }
+        const postChecksDiff = loggedSyncStage(options, input, "post_checks_diff_collect", () => collectRunDiff(runHandle), (result) => ({ changed_path_count: result.changed_paths.length }));
+        changedPaths = postChecksDiff.changed_paths;
+        docs = docsStatusForChangedPaths(changedPaths);
+        if (candidateChangedAfterChecks(diff, postChecksDiff)) {
+            const result = failedFinishedResult({
+                summary: "Checks modified the candidate workspace; promotion was not attempted.",
+                checks: {
+                    status: "failed",
+                    commands: checks.commands,
+                },
+                docs,
+                changedPaths,
+                promotion: promotionNotAttempted("checks_modified_candidate", "Checks changed tracked candidate files, so promotion was not attempted."),
+            });
+            return requestSelfCorrection({
+                result,
+                reasonCode: "checks_modified_candidate",
+                guidance: "Prevent checks from mutating tracked files, or intentionally produce those generated files before checks run.",
+            });
+        }
+        const commit = loggedSyncStage(options, input, "result_commit", () => createResultCommit(runHandle, `Complete Tutti task: ${input.task.title}`), (result) => ({ commit_oid: result.commit_oid }));
+        let promotion;
+        try {
+            promotion = loggedSyncStage(options, input, "promotion", () => promoteRunResult(runHandle, commit), (result) => ({ promoted_commit_oid: result.promoted_commit_oid }));
+        }
+        catch (error) {
+            if (isMainlineMovedPromotionConflict(error)) {
+                const reconcileResult = await loggedAsyncStage(options, input, "promotion_reconcile", () => runPromotionReconcile({
+                    options,
+                    pipelineInput: input,
+                    runHandle,
+                    taskOutput,
+                    sourceCommit: commit,
+                    changedPaths: postChecksDiff.changed_paths,
+                }), runResultLogFields);
+                const reasonCode = reconcileSelfCorrectionReason(reconcileResult);
+                if (reasonCode !== undefined) {
+                    return requestSelfCorrection({
+                        result: reconcileResult,
+                        reasonCode,
+                        guidance: "Rebuild the candidate from the latest mainline and resolve the promotion reconcile failure.",
+                    });
+                }
+                return reconcileResult;
+            }
+            throw error;
+        }
+        return {
+            result_kind: "finished",
+            outcome: "completed",
+            summary: successfulRunSummary({
+                implementation: taskOutput.summary,
+                checks,
+                completion: "Promotion complete.",
+            }),
+            checks: checkStatus(checks),
+            docs,
+            ...checkSkipFields(checks),
+            changed_paths: changedPaths,
+            promotion: {
+                status: "promoted",
+                commit_oid: promotion.promoted_commit_oid,
+                summary: "Promoted by fast-forward after checks.",
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof CodexAppServerWorkspaceWriteRunError) {
+            return summarizeProviderError(error);
+        }
+        if (error instanceof WorkspaceOpsError) {
+            return summarizeWorkspaceOpsError(error, changedPaths);
+        }
+        return failedBeforeChecks({
+            summary: error instanceof Error ? error.message : "Run pipeline failed",
+            errorCode: "run_pipeline_failed",
+            retryable: false,
+            ...(changedPaths === undefined ? {} : { changedPaths }),
+        });
+    }
+    finally {
+        const cleanupHandle = handle;
+        if (cleanupHandle !== undefined) {
+            loggedSyncStage(options, input, "run_workspace_cleanup", () => cleanupRunWorkspace(cleanupHandle));
+        }
+    }
+}
+export function createOpenAiRunPipelineRunner(options) {
+    return {
+        async runTask(input) {
+            let currentInput = input;
+            let selfCorrectionRetries = 0;
+            let providerTransientRetries = 0;
+            let carriedTimelineEvents = [];
+            for (;;) {
+                const result = await runTaskAttempt(options, currentInput);
+                if (isProviderTransientRunFailure(result) &&
+                    providerTransientRetries < MAX_PROVIDER_TRANSIENT_RETRIES) {
+                    providerTransientRetries += 1;
+                    input.on_stage?.({
+                        stage: "provider_retry",
+                        summary: "retrying Codex task after a transient provider failure.",
+                    });
+                    logRunPipelineStage(options, currentInput, {
+                        stage: "provider_retry",
+                        next_attempt: currentInput.run_lineage.attempt + 1,
+                        error_code: result.error_code,
+                    }, "Run pipeline scheduling provider transient retry");
+                    currentInput = providerTransientRetryInput(currentInput);
+                    continue;
+                }
+                providerTransientRetries = 0;
+                if (!isSelfCorrectionRequest(result)) {
+                    return withCarriedTimelineEvents(result, carriedTimelineEvents);
+                }
+                if (selfCorrectionRetries >= MAX_SELF_CORRECTION_RETRIES) {
+                    return withCarriedTimelineEvents(appendSelfCorrectionExhaustedSummary({
+                        result: result.fallback,
+                        attemptedRetries: selfCorrectionRetries,
+                    }), carriedTimelineEvents);
+                }
+                carriedTimelineEvents = [
+                    ...carriedTimelineEvents,
+                    ...resultTimelineEvents(result.fallback),
+                ];
+                selfCorrectionRetries += 1;
+                const correctionContext = result.correction_context;
+                const nextAttempt = currentInput.run_lineage.attempt + 1;
+                input.on_stage?.({
+                    stage: "self_correction",
+                    summary: "retrying task implementation after pipeline feedback.",
+                });
+                logRunPipelineStage(options, currentInput, {
+                    stage: "self_correction",
+                    next_attempt: nextAttempt,
+                    reason_code: correctionContext.reason_code,
+                }, "Run pipeline scheduling self-correction retry");
+                currentInput = selfCorrectionInput(input, nextAttempt, correctionContext);
+            }
+        },
+    };
+}
+export function resolveProjectOpenAiRunPipelineRunner(options) {
+    const resolution = resolveOpenAiProviderConfig({
+        tuttiHome: options.tuttiHome,
+        projectId: options.projectId,
+    });
+    if (resolution.kind === "unavailable") {
+        return { kind: "not_configured" };
+    }
+    const config = resolution.config;
+    let credential;
+    try {
+        credential = readOpenAiApiKeyCredential(options.tuttiHome, options.projectId, config.credential_ref);
+    }
+    catch {
+        return { kind: "not_configured" };
+    }
+    return {
+        kind: "ready",
+        runner: createOpenAiRunPipelineRunner({
+            config,
+            apiKey: credential.secret,
+            workspaceRoot: options.workspaceRoot,
+            runWorkspaceRoot: join(options.runWorkspaceRoot, "run-workspaces"),
+            mergeWorkspaceRoot: join(options.mergeWorkspaceRoot ?? options.runWorkspaceRoot, "merge-workspaces"),
+            tuttiHome: options.tuttiHome,
+            ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
+            ...(options.approvalManager === undefined
+                ? {}
+                : { approvalManager: options.approvalManager }),
+            ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+            ...(options.logger === undefined ? {} : { logger: options.logger }),
+            ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+        }),
+    };
+}
+//# sourceMappingURL=openai.js.map

package/dist/run-pipeline/promotion-reconcile.d.ts

@@ -0,0 +1,13 @@
+import type { RunPipelineInput, RunPipelineResult } from "../control-plane/index.js";
+import { type ResultCommit, type RunWorkspaceHandle } from "../workspace-ops/index.js";
+import type { OpenAiRunPipelineRunnerOptions } from "./openai.js";
+import type { TaskRunOutput } from "./task-run-output.js";
+export declare function runPromotionReconcile(input: {
+    options: OpenAiRunPipelineRunnerOptions;
+    pipelineInput: RunPipelineInput;
+    runHandle: RunWorkspaceHandle;
+    taskOutput: TaskRunOutput;
+    sourceCommit: ResultCommit;
+    changedPaths: string[];
+}): Promise<RunPipelineResult>;
+//# sourceMappingURL=promotion-reconcile.d.ts.map