@shenlee/devcrew 0.1.2 → 0.1.4

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

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { devcrewDir, repositoryLockPath } from "./paths.js";
+function metadataPath(cwd) {
+    return `${repositoryLockPath(cwd)}/lock.json`;
+}
+async function readMetadata(cwd) {
+    try {
+        const parsed = JSON.parse(await readFile(metadataPath(cwd), "utf8"));
+        const pid = parsed.pid;
+        if (typeof parsed.ownerId !== "string" ||
+            typeof pid !== "number" ||
+            !Number.isInteger(pid) ||
+            typeof parsed.createdAt !== "string") {
+            return undefined;
+        }
+        return {
+            ownerId: parsed.ownerId,
+            pid,
+            createdAt: parsed.createdAt,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function processIsLive(pid) {
+    if (pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function releaseRepositoryLock(cwd, ownerId) {
+    const metadata = await readMetadata(cwd);
+    if (metadata?.ownerId === ownerId) {
+        await rm(repositoryLockPath(cwd), { recursive: true, force: true });
+    }
+}
+export async function withRepositoryLock(cwd, action) {
+    await mkdir(devcrewDir(cwd), { recursive: true });
+    const ownerId = randomUUID();
+    try {
+        await mkdir(repositoryLockPath(cwd));
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+        const metadata = await readMetadata(cwd);
+        if (metadata && processIsLive(metadata.pid)) {
+            throw new Error("A DevCrew operation is already in progress for this repository");
+        }
+        throw new Error("A stale DevCrew repository lock exists; use devcrew_recover for explicit recovery");
+    }
+    await writeFile(metadataPath(cwd), `${JSON.stringify({ ownerId, pid: process.pid, createdAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
+    try {
+        return await action();
+    }
+    finally {
+        await releaseRepositoryLock(cwd, ownerId);
+    }
+}
+export async function recoverRepositoryLock(cwd) {
+    const lockPath = repositoryLockPath(cwd);
+    const metadata = await readMetadata(cwd);
+    if (!metadata) {
+        try {
+            await rm(lockPath, { recursive: true, force: false });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    if (processIsLive(metadata.pid)) {
+        throw new Error("Cannot recover a DevCrew repository lock held by a live process");
+    }
+    await rm(lockPath, { recursive: true, force: true });
+    return true;
+}

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

@@ -21,25 +21,29 @@ export function configPath(cwd) {
 export function activeRunPath(cwd) {
     return join(devcrewDir(cwd), "active-run.json");
 }
+export function repositoryLockPath(cwd) {
+    return join(devcrewDir(cwd), "lock");
+}
 export function standardsPath(cwd) {
     return join(devcrewDir(cwd), "standards.md");
 }
-export function docsRoot(cwd) {
-    return join(cwd, "docs", "devcrew");
+export function docsRoot(cwd, artifactDirectory = "docs/devcrew") {
+    return join(cwd, artifactDirectory);
 }
-export function docsRunDir(cwd, runId) {
-    return join(docsRoot(cwd), runId);
+export function docsRunDir(cwd, runId, artifactDirectory = "docs/devcrew") {
+    return join(docsRoot(cwd, artifactDirectory), runId);
 }
-export function artifactPath(cwd, runId, artifact) {
+export function artifactPath(cwd, runId, artifact, artifactDirectory = "docs/devcrew") {
     const filenameByArtifact = {
         requirements: "requirements.md",
         architecture: "architecture.md",
         "implementation-plan": "implementation-plan.md",
         "implementation-review": "implementation-review.md",
+        "architecture-review": "architecture-review.md",
         "test-report": "test-report.md",
         acceptance: "acceptance.md",
     };
-    return join(docsRunDir(cwd, runId), filenameByArtifact[artifact]);
+    return join(docsRunDir(cwd, runId, artifactDirectory), filenameByArtifact[artifact]);
 }
 export async function ensureRunDirectories(cwd, runId) {
     await mkdir(runDir(cwd, runId), { recursive: true });

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

@@ -1,6 +1,22 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { ensureRunDirectories, statePath } from "./paths.js";
+import { GATES } from "./types.js";
+function enabledGatesFromState(value) {
+    const configured = Array.isArray(value)
+        ? value.filter((gate) => typeof gate === "string" && GATES.includes(gate))
+        : [...GATES];
+    return [...new Set([...configured, "implementation-review", "testing"])];
+}
+function roleResultsFromState(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((role) => typeof role === "object" && role !== null).map((role) => ({
+        ...role,
+        format: role.format === "structured" ? "structured" : "legacy",
+    }));
+}
 export async function saveState(state) {
     state.updatedAt = new Date().toISOString();
     await ensureRunDirectories(state.cwd, state.runId);
@@ -14,17 +30,41 @@ export async function loadState(cwd, runId) {
     const raw = await readFile(statePath(cwd, runId), "utf8");
     const parsed = JSON.parse(raw);
     const executionWorkspace = parsed.executionWorkspace;
+    const executionInstruction = parsed.executionInstruction;
+    const verificationWaiver = parsed.verificationWaiver;
     return {
         ...parsed,
         executionMode: parsed.executionMode ?? "plan",
+        executionPolicy: parsed.executionPolicy ?? "interactive-host",
+        roles: roleResultsFromState(parsed.roles),
+        enabledGates: enabledGatesFromState(parsed.enabledGates),
+        artifactDirectory: typeof parsed.artifactDirectory === "string" && parsed.artifactDirectory.trim().length > 0
+            ? parsed.artifactDirectory
+            : "docs/devcrew",
         executionWorkspace: executionWorkspace &&
             typeof executionWorkspace.path === "string" &&
             typeof executionWorkspace.baseCommit === "string"
             ? executionWorkspace
             : undefined,
+        executionInstruction: executionInstruction &&
+            (executionInstruction.phase === "execution" || executionInstruction.phase === "testing") &&
+            typeof executionInstruction.workspacePath === "string" &&
+            typeof executionInstruction.instructions === "string" &&
+            typeof executionInstruction.createdAt === "string"
+            ? executionInstruction
+            : undefined,
         changedFiles: Array.isArray(parsed.changedFiles) ? parsed.changedFiles : [],
+        pendingQuestions: Array.isArray(parsed.pendingQuestions)
+            ? parsed.pendingQuestions.filter((question) => typeof question === "string" && question.trim().length > 0)
+            : [],
         implementationDiff: typeof parsed.implementationDiff === "string" ? parsed.implementationDiff : "",
         verification: Array.isArray(parsed.verification) ? parsed.verification : [],
+        verificationStatus: parsed.verificationStatus === "passed" || parsed.verificationStatus === "failed" ? parsed.verificationStatus : "not_run",
+        verificationWaiver: verificationWaiver &&
+            typeof verificationWaiver.reason === "string" &&
+            typeof verificationWaiver.createdAt === "string"
+            ? verificationWaiver
+            : undefined,
         lintResults: Array.isArray(parsed.lintResults) ? parsed.lintResults : [],
     };
 }

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

@@ -1,5 +1,6 @@
 export const WORKFLOW_MODES = ["feature", "greenfield"];
 export const EXECUTION_MODES = ["plan", "apply"];
+export const EXECUTION_POLICIES = ["interactive-host", "headless-restricted", "headless-unattended"];
 export const HOSTS = ["codex", "claude"];
 export const BACKENDS = ["codex", "claude", "local"];
 export const PHASES = [
@@ -7,16 +8,18 @@ export const PHASES = [
     "architecture",
     "implementation",
     "execution",
+    "review",
     "testing",
     "acceptance",
     "complete",
 ];
-export const GATES = ["requirements", "architecture", "implementation", "testing"];
+export const GATES = ["requirements", "architecture", "implementation", "implementation-review", "testing"];
 export const ARTIFACTS = [
     "requirements",
     "architecture",
     "implementation-plan",
     "implementation-review",
+    "architecture-review",
     "test-report",
     "acceptance",
 ];

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

@@ -1,4 +1,4 @@
-import { ARTIFACTS, BACKENDS, EXECUTION_MODES, GATES, HOSTS, WORKFLOW_MODES, } from "./types.js";
+import { ARTIFACTS, BACKENDS, EXECUTION_MODES, EXECUTION_POLICIES, GATES, HOSTS, WORKFLOW_MODES, } from "./types.js";
 function assertString(value, field) {
     if (typeof value !== "string" || value.trim().length === 0) {
         throw new Error(`${field} must be a non-empty string`);
@@ -17,6 +17,9 @@ export function parseWorkflowMode(value) {
 export function parseExecutionMode(value) {
     return oneOf(value, "executionMode", EXECUTION_MODES);
 }
+export function parseExecutionPolicy(value) {
+    return oneOf(value, "executionPolicy", EXECUTION_POLICIES);
+}
 export function parseHost(value) {
     return oneOf(value, "host", HOSTS);
 }
@@ -50,3 +53,6 @@ export function parseFeedback(value) {
 export function parseAnswer(value) {
     return assertString(value, "answer");
 }
+export function parseWaiverReason(value) {
+    return assertString(value, "reason");
+}

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

@@ -1,2 +1,2 @@
-export const DEVCREW_VERSION = "0.1.2";
+export const DEVCREW_VERSION = "0.1.4";
 export const DEVCREW_NPM_PACKAGE = "@shenlee/devcrew";

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

@@ -3,7 +3,8 @@ 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();
 }
@@ -18,6 +19,8 @@ export function nextPhaseAfterGate(state, gate) {
             return "implementation";
         case "implementation":
             return state.executionMode === "apply" ? "execution" : "testing";
+        case "implementation-review":
+            return "testing";
         case "testing":
             return "acceptance";
     }
@@ -28,20 +31,32 @@ export function artifactForPhase(phase) {
         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 assertPendingCurrentGate(state, gate) {
-    const expected = gateForPhase(state.phase);
+    const expected = gateForPhase(state.phase, state.enabledGates);
     if (expected !== gate) {
         throw new Error(expected
             ? `Cannot act on ${gate} while current gate is ${expected}`
@@ -65,6 +80,8 @@ 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");
     }
@@ -76,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: [],
@@ -97,6 +119,7 @@ export async function startWorkflow(input, options = {}) {
         changedFiles: [],
         implementationDiff: "",
         verification: [],
+        verificationStatus: "not_run",
         lintResults: [],
     };
     if (!options.skipArtifactWrite) {
@@ -109,7 +132,11 @@ 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" ||
+        state.status === "aborted") {
         return state;
     }
     if (state.phase === "acceptance") {
@@ -121,8 +148,14 @@ export async function continueWorkflow(input) {
     if (state.phase === "execution") {
         throw new Error("DevCrew execution phase requires orchestrated continuation");
     }
-    const gate = gateForPhase(state.phase);
+    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);
     }
@@ -131,6 +164,22 @@ export async function continueWorkflow(input) {
     await writeCurrentArtifact(state);
     return saveState(state);
 }
+export async function abortWorkflow(input) {
+    const state = await getWorkflowStatus(input);
+    if (state.status === "aborted") {
+        return state;
+    }
+    if (state.status === "complete") {
+        throw new Error("Completed DevCrew runs cannot be aborted");
+    }
+    state.abort = {
+        reason: parseWaiverReason(input.reason),
+        abortedAt: now(),
+    };
+    delete state.executionInstruction;
+    state.status = "aborted";
+    return saveState(state);
+}
 export async function validateWorkflowApproval(input) {
     const state = await getWorkflowStatus(input);
     const gate = parseGate(input.gate);
@@ -176,7 +225,16 @@ export async function rejectWorkflow(input) {
 }
 export async function answerWorkflow(input, options = {}) {
     const state = await getWorkflowStatus(input);
-    const gate = gateForPhase(state.phase);
+    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");
     }
@@ -191,6 +249,23 @@ export async function answerWorkflow(input, options = {}) {
     }
     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" && state.verificationStatus !== "not_run")) {
+        throw new Error("A verification waiver is only available after failed or missing apply-mode verification");
+    }
+    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));