@xfey/tutti 0.1.0

package/dist/run-engine/index.js

@@ -0,0 +1,140 @@
+import { createActivityRef } from "@tutti/shared/ids";
+export class RunEngine {
+    active = null;
+    lastConclusion = null;
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+    }
+    startRun(options) {
+        if (this.active !== null) {
+            return {
+                kind: "already_running",
+                activity_ref: this.active.activity.activity_ref,
+            };
+        }
+        const startedAt = (options.now ?? this.now)().toISOString();
+        const activityRef = options.activity_ref ?? createActivityRef();
+        const activity = {
+            activity_ref: activityRef,
+            activity_kind: "run",
+            status: "running",
+            title: options.title,
+            summary: options.summary,
+            task_id: options.task.id,
+            run_lineage: options.run_lineage,
+            started_at: startedAt,
+            result_anchor: {
+                kind: "task",
+                task_id: options.task.id,
+            },
+        };
+        const context = {
+            activity_ref: activityRef,
+            task_id: options.task.id,
+            run_lineage: options.run_lineage,
+            reportProgress: (progress) => this.updateActiveProgress(activityRef, progress, options.onTransition),
+        };
+        const run = async () => {
+            try {
+                const conclusion = await options.execute(context);
+                this.finishActive(activityRef, conclusion, options.onTransition);
+            }
+            catch (error) {
+                this.finishActive(activityRef, {
+                    kind: "failed",
+                    summary: error instanceof Error ? error.message : "Run failed",
+                }, options.onTransition);
+            }
+        };
+        const promise = Promise.resolve().then(run);
+        this.active = { activity, task: options.task, promise };
+        options.onTransition?.(this.state("started"));
+        return {
+            kind: "accepted",
+            activity,
+        };
+    }
+    getExecutionStatus() {
+        if (this.active !== null) {
+            return {
+                status: "running",
+                summary: this.active.activity.summary,
+                active_task: this.active.task,
+                active_activity: {
+                    activity_ref: this.active.activity.activity_ref,
+                    activity_kind: "run",
+                    ...(this.active.activity.started_at === undefined
+                        ? {}
+                        : { started_at: this.active.activity.started_at }),
+                },
+                updated_at: this.now().toISOString(),
+            };
+        }
+        const idle = {
+            status: "idle",
+            summary: "Idle",
+            updated_at: this.now().toISOString(),
+        };
+        if (this.lastConclusion !== null) {
+            idle.last_conclusion = this.lastConclusion;
+        }
+        return idle;
+    }
+    async waitForIdle() {
+        while (this.active !== null) {
+            await this.active.promise;
+        }
+    }
+    state(transitionKind, progress) {
+        if (this.active === null) {
+            throw new Error("Run engine has no active run");
+        }
+        const state = {
+            activity: this.active.activity,
+            execution_status: this.getExecutionStatus(),
+            transition_kind: transitionKind,
+        };
+        if (progress !== undefined) {
+            state.progress = progress;
+        }
+        return state;
+    }
+    updateActiveProgress(activityRef, progress, onTransition) {
+        const active = this.active;
+        if (active === null || active.activity.activity_ref !== activityRef) {
+            return;
+        }
+        active.activity.summary = progress.summary;
+        onTransition?.(this.state("progress", progress));
+    }
+    finishActive(activityRef, conclusion, onTransition) {
+        const active = this.active;
+        if (active === null || active.activity.activity_ref !== activityRef) {
+            return;
+        }
+        const endedAt = this.now().toISOString();
+        active.activity.status =
+            conclusion.kind === "completed"
+                ? "finished"
+                : conclusion.kind === "needs_human"
+                    ? "needs_human"
+                    : "failed";
+        active.activity.summary = conclusion.summary;
+        active.activity.ended_at = endedAt;
+        this.lastConclusion = {
+            kind: conclusion.kind,
+            summary: conclusion.summary,
+            task_id: active.task.id,
+            activity_ref: activityRef,
+            occurred_at: endedAt,
+        };
+        this.active = null;
+        onTransition?.({
+            activity: active.activity,
+            execution_status: this.getExecutionStatus(),
+            transition_kind: "terminal",
+        });
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/run-pipeline/candidate-diff.d.ts

@@ -0,0 +1,3 @@
+import type { RunDiffSummary } from "../workspace-ops/index.js";
+export declare function candidateChangedAfterChecks(before: RunDiffSummary, after: RunDiffSummary): boolean;
+//# sourceMappingURL=candidate-diff.d.ts.map

package/dist/run-pipeline/candidate-diff.js

@@ -0,0 +1,10 @@
+function sameChangedPaths(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((path, index) => path === right[index]);
+}
+export function candidateChangedAfterChecks(before, after) {
+    return (!sameChangedPaths(before.changed_paths, after.changed_paths) || before.summary !== after.summary);
+}
+//# sourceMappingURL=candidate-diff.js.map

package/dist/run-pipeline/openai.d.ts

@@ -0,0 +1,41 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { ApprovalRequestManager } from "../approvals/index.js";
+import type { ControlPlaneLogger, RunPipelineResolution, RunPipelineRunner } from "../control-plane/index.js";
+import type { ProviderUsageRecorder } from "../provider-usage/index.js";
+import { type OpenAiProviderConfig } from "../providers/openai/provider-config.js";
+import type { CodexAppServerAgentContextRuntime } from "../providers/openai/app-server/skills.js";
+export { TASK_RUN_OUTPUT_SCHEMA } from "./task-run-output.js";
+export type OpenAiRunPipelineRunnerOptions = {
+    config: OpenAiProviderConfig;
+    apiKey: string;
+    workspaceRoot: string;
+    runWorkspaceRoot: string;
+    mergeWorkspaceRoot?: string;
+    promptsRoot?: string;
+    tuttiHome?: string;
+    builtInSkillsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    approvalManager?: ApprovalRequestManager;
+    codexCommand?: string;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    checkTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+    logger?: ControlPlaneLogger | undefined;
+    recordUsage?: ProviderUsageRecorder;
+};
+export type ProjectOpenAiRunPipelineRunnerOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    runWorkspaceRoot: string;
+    mergeWorkspaceRoot?: string;
+    promptsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    approvalManager?: ApprovalRequestManager;
+    logger?: ControlPlaneLogger | undefined;
+    recordUsage?: ProviderUsageRecorder;
+};
+export declare function createOpenAiRunPipelineRunner(options: OpenAiRunPipelineRunnerOptions): RunPipelineRunner;
+export declare function resolveProjectOpenAiRunPipelineRunner(options: ProjectOpenAiRunPipelineRunnerOptions): RunPipelineResolution;
+//# sourceMappingURL=openai.d.ts.map