@shenlee/devcrew 0.1.1 → 0.1.3

package/dist/packages/core/src/workflow.js

@@ -3,43 +3,67 @@ import { ensureConfig } from "./config.js";
 import { readArtifact, writeArtifact } from "./artifacts.js";
 import { discoverStandards } from "./standards.js";
 import { loadState, saveState } from "./store.js";
-import { parseAnswer, parseArtifactName, parseBackend, parseCwd, parseExecutionMode, parseFeedback, parseGate, parseHost, parseOptionalNote, parseRequest, parseRunId, parseWorkflowMode, } from "./validation.js";
+import { parseAnswer, parseArtifactName, parseBackend, parseCwd, parseExecutionMode, parseExecutionPolicy, parseFeedback, parseGate, parseHost, parseOptionalNote, parseRequest, parseRunId, parseWaiverReason, parseWorkflowMode, } from "./validation.js";
+import { GATES } from "./types.js";
 function now() {
     return new Date().toISOString();
 }
 function newRunId() {
     return `dc-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
-export function nextPhaseAfterGate(gate) {
-    const nextByGate = {
-        requirements: "architecture",
-        architecture: "implementation",
-        implementation: "testing",
-        testing: "acceptance",
-    };
-    return nextByGate[gate];
+export function nextPhaseAfterGate(state, gate) {
+    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) {
     const artifactByPhase = {
         requirements: "requirements",
         architecture: "architecture",
         implementation: "implementation-plan",
+        execution: "implementation-review",
+        review: "architecture-review",
         testing: "test-report",
         acceptance: "acceptance",
         complete: "acceptance",
     };
     return artifactByPhase[phase];
 }
-export function gateForPhase(phase) {
-    if (phase === "requirements" || phase === "architecture" || phase === "implementation" || phase === "testing") {
-        return phase;
-    }
-    return undefined;
+export function gateForPhase(phase, enabledGates) {
+    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) {
+    const configured = new Set(gates.filter((gate) => GATES.includes(gate)));
+    configured.add("implementation-review");
+    configured.add("testing");
+    return [...configured];
 }
-function assertCurrentGate(state, gate) {
-    const expected = gateForPhase(state.phase);
-    if (expected && expected !== gate) {
-        throw new Error(`Cannot act on ${gate} while current gate is ${expected}`);
+function assertPendingCurrentGate(state, gate) {
+    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`);
     }
 }
 async function writeCurrentArtifact(state) {
@@ -56,6 +80,11 @@ export async function startWorkflow(input, options = {}) {
     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 = {
         version: 1,
@@ -64,20 +93,25 @@ export async function startWorkflow(input, options = {}) {
         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: [],
@@ -85,6 +119,7 @@ export async function startWorkflow(input, options = {}) {
         changedFiles: [],
         implementationDiff: "",
         verification: [],
+        verificationStatus: "not_run",
         lintResults: [],
     };
     if (!options.skipArtifactWrite) {
@@ -97,7 +132,10 @@ export async function getWorkflowStatus(input) {
 }
 export async function continueWorkflow(input) {
     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;
     }
     if (state.phase === "acceptance") {
@@ -106,8 +144,17 @@ export async function continueWorkflow(input) {
         state.status = "complete";
         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);
     }
@@ -116,17 +163,29 @@ export async function continueWorkflow(input) {
     await writeCurrentArtifact(state);
     return saveState(state);
 }
-export async function approveWorkflow(input) {
+export async function validateWorkflowApproval(input) {
     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) {
+    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,
         note: parseOptionalNote(input.note),
         createdAt: now(),
     });
-    const nextPhase = nextPhaseAfterGate(gate);
+    const nextPhase = nextPhaseAfterGate(state, gate);
     state.phase = nextPhase;
     state.status = "ready";
     return saveState(state);
@@ -134,7 +193,10 @@ export async function approveWorkflow(input) {
 export async function rejectWorkflow(input) {
     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({
@@ -146,20 +208,47 @@ export async function rejectWorkflow(input) {
 }
 export async function answerWorkflow(input, options = {}) {
     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) {
+    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) {
     const state = await getWorkflowStatus(input);
     return readArtifact(state, parseArtifactName(input.name));