@shenlee/devcrew 0.1.1 → 0.1.3

package/packages/core/src/workflow.ts

@@ -10,12 +10,14 @@ import {
   parseBackend,
   parseCwd,
   parseExecutionMode,
+  parseExecutionPolicy,
   parseFeedback,
   parseGate,
   parseHost,
   parseOptionalNote,
   parseRequest,
   parseRunId,
+  parseWaiverReason,
   parseWorkflowMode,
 } from "./validation.js";
 import type {
@@ -29,7 +31,9 @@ import type {
   RunRef,
   RunState,
   StartWorkflowInput,
+  WaiveVerificationInput,
 } from "./types.js";
+import { GATES } from "./types.js";
 
 function now(): string {
   return new Date().toISOString();
@@ -39,14 +43,19 @@ function newRunId(): string {
   return `dc-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
 
-export function nextPhaseAfterGate(gate: GateName): RunState["phase"] {
-  const nextByGate: Record<GateName, RunState["phase"]> = {
-    requirements: "architecture",
-    architecture: "implementation",
-    implementation: "testing",
-    testing: "acceptance",
-  };
-  return nextByGate[gate];
+export function nextPhaseAfterGate(state: RunState, gate: GateName): RunState["phase"] {
+  switch (gate) {
+    case "requirements":
+      return "architecture";
+    case "architecture":
+      return "implementation";
+    case "implementation":
+      return state.executionMode === "apply" ? "execution" : "testing";
+    case "implementation-review":
+      return "testing";
+    case "testing":
+      return "acceptance";
+  }
 }
 
 export function artifactForPhase(phase: RunState["phase"]): ArtifactName {
@@ -54,6 +63,8 @@ export function artifactForPhase(phase: RunState["phase"]): ArtifactName {
     requirements: "requirements",
     architecture: "architecture",
     implementation: "implementation-plan",
+    execution: "implementation-review",
+    review: "architecture-review",
     testing: "test-report",
     acceptance: "acceptance",
     complete: "acceptance",
@@ -61,17 +72,40 @@ export function artifactForPhase(phase: RunState["phase"]): ArtifactName {
   return artifactByPhase[phase];
 }
 
-export function gateForPhase(phase: RunState["phase"]): GateName | undefined {
-  if (phase === "requirements" || phase === "architecture" || phase === "implementation" || phase === "testing") {
-    return phase;
-  }
-  return undefined;
+export function gateForPhase(phase: RunState["phase"], enabledGates?: readonly GateName[]): GateName | undefined {
+  const gate = phase === "review"
+    ? "implementation-review"
+    : (
+    phase === "requirements" ||
+    phase === "architecture" ||
+    phase === "implementation" ||
+    phase === "testing"
+      ? phase
+      : undefined
+    );
+  return gate && (!enabledGates || enabledGates.includes(gate)) ? gate : undefined;
+}
+
+function configuredGates(gates: readonly GateName[]): GateName[] {
+  const configured = new Set(
+    gates.filter((gate): gate is GateName => GATES.includes(gate)),
+  );
+  configured.add("implementation-review");
+  configured.add("testing");
+  return [...configured];
 }
 
-function assertCurrentGate(state: RunState, gate: GateName): void {
-  const expected = gateForPhase(state.phase);
-  if (expected && expected !== gate) {
-    throw new Error(`Cannot act on ${gate} while current gate is ${expected}`);
+function assertPendingCurrentGate(state: RunState, gate: GateName): void {
+  const expected = gateForPhase(state.phase, state.enabledGates);
+  if (expected !== gate) {
+    throw new Error(
+      expected
+        ? `Cannot act on ${gate} while current gate is ${expected}`
+        : `Cannot act on ${gate} while workflow phase is ${state.phase}`,
+    );
+  }
+  if (state.status !== "awaiting_approval" || state.gates[gate] !== "pending") {
+    throw new Error(`Gate ${gate} is not pending approval`);
   }
 }
 
@@ -94,6 +128,11 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
   const config = await ensureConfig(cwd);
   const backend = input.backend ? parseBackend(input.backend) : config.defaultBackend === "host-preferred" ? host : config.defaultBackend;
   const executionMode = input.executionMode ? parseExecutionMode(input.executionMode) : config.executionMode;
+  const executionPolicy = input.executionPolicy ? parseExecutionPolicy(input.executionPolicy) : "interactive-host";
+  const enabledGates = configuredGates(config.workflow.gates);
+  if (executionMode === "apply" && backend === "local") {
+    throw new Error("DevCrew apply mode requires a codex or claude backend; local is plan-only");
+  }
   const createdAt = now();
   const state: RunState = {
     version: 1,
@@ -102,20 +141,25 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
     host,
     mode,
     executionMode,
+    executionPolicy,
+    enabledGates,
+    artifactDirectory: config.workflow.artifactDirectory,
     backend,
     request,
     phase: "requirements",
-    status: "awaiting_approval",
+    status: enabledGates.includes("requirements") ? "awaiting_approval" : "ready",
     createdAt,
     updatedAt: createdAt,
     gates: {
-      requirements: "pending",
+      requirements: enabledGates.includes("requirements") ? "pending" : "not_started",
       architecture: "not_started",
       implementation: "not_started",
+      "implementation-review": "not_started",
       testing: "not_started",
     },
     artifacts: {},
     roles: [],
+    pendingQuestions: [],
     answers: [],
     approvals: [],
     feedback: [],
@@ -123,6 +167,7 @@ export async function startWorkflow(input: StartWorkflowInput, options: Workflow
     changedFiles: [],
     implementationDiff: "",
     verification: [],
+    verificationStatus: "not_run",
     lintResults: [],
   };
 
@@ -138,7 +183,12 @@ export async function getWorkflowStatus(input: RunRef): Promise<RunState> {
 
 export async function continueWorkflow(input: RunRef): Promise<RunState> {
   const state = await getWorkflowStatus(input);
-  if (state.status === "awaiting_approval" || state.status === "awaiting_input" || state.status === "complete") {
+  if (
+    state.status === "awaiting_approval" ||
+    state.status === "awaiting_input" ||
+    state.status === "awaiting_execution" ||
+    state.status === "complete"
+  ) {
     return state;
   }
 
@@ -149,8 +199,18 @@ export async function continueWorkflow(input: RunRef): Promise<RunState> {
     return saveState(state);
   }
 
-  const gate = gateForPhase(state.phase);
+  if (state.phase === "execution") {
+    throw new Error("DevCrew execution phase requires orchestrated continuation");
+  }
+
+  const configuredGate = gateForPhase(state.phase);
+  const gate = gateForPhase(state.phase, state.enabledGates);
   if (!gate) {
+    if (configuredGate) {
+      state.phase = nextPhaseAfterGate(state, configuredGate);
+      state.status = "ready";
+      return saveState(state);
+    }
     state.status = "complete";
     return saveState(state);
   }
@@ -160,10 +220,23 @@ export async function continueWorkflow(input: RunRef): Promise<RunState> {
   return saveState(state);
 }
 
-export async function approveWorkflow(input: ApproveWorkflowInput): Promise<RunState> {
+export async function validateWorkflowApproval(input: ApproveWorkflowInput): Promise<RunState> {
   const state = await getWorkflowStatus(input);
   const gate = parseGate(input.gate);
-  assertCurrentGate(state, gate);
+  if (state.gates[gate] === "approved") {
+    return state;
+  }
+  assertPendingCurrentGate(state, gate);
+  parseOptionalNote(input.note);
+  return state;
+}
+
+export async function approveWorkflow(input: ApproveWorkflowInput): Promise<RunState> {
+  const state = await validateWorkflowApproval(input);
+  const gate = parseGate(input.gate);
+  if (state.gates[gate] === "approved") {
+    return state;
+  }
   state.gates[gate] = "approved";
   state.approvals.push({
     gate,
@@ -171,7 +244,7 @@ export async function approveWorkflow(input: ApproveWorkflowInput): Promise<RunS
     createdAt: now(),
   });
 
-  const nextPhase = nextPhaseAfterGate(gate);
+  const nextPhase = nextPhaseAfterGate(state, gate);
   state.phase = nextPhase;
   state.status = "ready";
   return saveState(state);
@@ -180,7 +253,10 @@ export async function approveWorkflow(input: ApproveWorkflowInput): Promise<RunS
 export async function rejectWorkflow(input: RejectWorkflowInput): Promise<RunState> {
   const state = await getWorkflowStatus(input);
   const gate = parseGate(input.gate);
-  assertCurrentGate(state, gate);
+  if (state.gates[gate] === "rejected") {
+    return state;
+  }
+  assertPendingCurrentGate(state, gate);
   state.gates[gate] = "rejected";
   state.status = "awaiting_input";
   state.feedback.push({
@@ -193,21 +269,51 @@ export async function rejectWorkflow(input: RejectWorkflowInput): Promise<RunSta
 
 export async function answerWorkflow(input: AnswerWorkflowInput, options: WorkflowMutationOptions = {}): Promise<RunState> {
   const state = await getWorkflowStatus(input);
+  const gate = gateForPhase(state.phase, state.enabledGates);
+  if (state.status === "awaiting_input" && state.pendingQuestions.length > 0 && state.phase === "requirements") {
+    state.answers.push({
+      answer: parseAnswer(input.answer),
+      createdAt: now(),
+    });
+    state.pendingQuestions = [];
+    state.status = "ready";
+    return saveState(state);
+  }
+  if (state.status !== "awaiting_input" || !gate || state.gates[gate] !== "rejected") {
+    throw new Error("Workflow must be awaiting_input at a rejected current gate before recording an answer");
+  }
   state.answers.push({
     answer: parseAnswer(input.answer),
     createdAt: now(),
   });
-  const gate = gateForPhase(state.phase);
-  if (gate) {
-    state.gates[gate] = "pending";
-    state.status = "awaiting_approval";
-  }
+  state.gates[gate] = "pending";
+  state.status = "awaiting_approval";
   if (!options.skipArtifactWrite) {
     await writeCurrentArtifact(state);
   }
   return saveState(state);
 }
 
+export async function waiveVerificationWorkflow(input: WaiveVerificationInput): Promise<RunState> {
+  const state = await getWorkflowStatus(input);
+  if (
+    state.executionMode !== "apply" ||
+    state.phase !== "testing" ||
+    state.status !== "awaiting_input" ||
+    state.gates.testing !== "rejected" ||
+    state.verificationStatus !== "failed"
+  ) {
+    throw new Error("A verification waiver is only available after failed apply-mode testing");
+  }
+  state.verificationWaiver = {
+    reason: parseWaiverReason(input.reason),
+    createdAt: now(),
+  };
+  state.gates.testing = "pending";
+  state.status = "awaiting_approval";
+  return saveState(state);
+}
+
 export async function getArtifact(input: ArtifactRef): Promise<ArtifactReadResult> {
   const state = await getWorkflowStatus(input);
   return readArtifact(state, parseArtifactName(input.name));