@shenlee/devcrew 0.1.0

package/dist/packages/adapters/src/index.js

@@ -0,0 +1,234 @@
+import { DEVCREW_NPM_PACKAGE, ROLE_SECTIONS } from "../../core/src/index.js";
+export function resolveBackendName(input) {
+    if (input.configuredBackend && input.configuredBackend !== "host-preferred") {
+        return input.configuredBackend;
+    }
+    return input.host;
+}
+// Prompt-formatted role sections derived from the shared ROLE_SECTIONS constant.
+export function roleGuidance(role) {
+    const sections = ROLE_SECTIONS[role];
+    if (!sections || sections.length === 0) {
+        return [];
+    }
+    const lines = ["Produce these exact H2 sections:"];
+    for (const section of sections) {
+        lines.push(`## ${section.heading}`, `Guidance: ${section.description}.`);
+    }
+    return lines;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function missingRoleSections(role, markdown) {
+    const sections = ROLE_SECTIONS[role];
+    if (!sections || sections.length === 0) {
+        return [];
+    }
+    return sections
+        .map((section) => section.heading)
+        .filter((heading) => !new RegExp(`^##\\s+${escapeRegExp(heading)}\\s*$`, "imu").test(markdown));
+}
+export class RoleOutputValidationError extends Error {
+    constructor(role, missingSections) {
+        super(`DevCrew ${role} output is missing required sections: ${missingSections.join(", ")}`);
+        this.name = "RoleOutputValidationError";
+    }
+}
+export function assertRoleSections(role, markdown) {
+    const missingSections = missingRoleSections(role, markdown);
+    if (missingSections.length > 0) {
+        throw new RoleOutputValidationError(role, missingSections);
+    }
+}
+export function renderRolePrompt(input) {
+    const executionMode = input.executionMode ?? "plan";
+    const answers = input.answers ?? [];
+    const feedback = input.feedback ?? [];
+    const priorArtifacts = input.priorArtifacts ?? {};
+    const lines = [
+        `Role: ${input.role}`,
+        `Phase: ${input.phase}`,
+        `Mode: ${input.mode}`,
+        `Execution Mode: ${executionMode}`,
+        `Request: ${input.request}`,
+        `Artifact Path: ${input.artifactPath}`,
+        "",
+        "Project Standards:",
+        input.standards,
+    ];
+    if (answers.length > 0) {
+        lines.push("", "Requester Answers:", ...answers.map((answer, index) => `${index + 1}. ${answer}`));
+    }
+    if (feedback.length > 0) {
+        lines.push("", "Rejection Feedback To Address:", ...feedback.map((entry) => `- ${entry}`));
+    }
+    const artifactEntries = Object.entries(priorArtifacts);
+    if (artifactEntries.length > 0) {
+        lines.push("", "Prior Artifacts:");
+        for (const [name, content] of artifactEntries) {
+            lines.push("", `### ${name}`, content.trim());
+        }
+    }
+    const canApply = executionMode === "apply" && (input.role === "implementer" || input.role === "tester");
+    const permissionInstruction = canApply
+        ? input.role === "tester"
+            ? "You may run validation commands needed for the approved scope and report exact evidence."
+            : "You may modify repository files needed for the approved scope and report changed files."
+        : "Do not modify repository files. Return only the Markdown document content for the artifact.";
+    lines.push("", "Instructions:", `Act as the DevCrew ${input.role} role and produce a complete, well-structured Markdown document for the ${input.phase} phase.`, "Keep scope aligned with the approved gates and inherited host permissions.", permissionInstruction, "", "Required Sections:", ...roleGuidance(input.role));
+    return lines.join("\n");
+}
+function titleForPhase(phase) {
+    return {
+        requirements: "Requirements",
+        architecture: "Architecture",
+        implementation: "Implementation Plan",
+        testing: "Test Report",
+        acceptance: "Acceptance",
+        complete: "Acceptance",
+    }[phase];
+}
+export const HOST_SDK_PACKAGES = {
+    codex: "@openai/codex-sdk",
+    claude: "@anthropic-ai/claude-agent-sdk",
+};
+// Dynamic import with a non-literal specifier so the optional host SDKs do not
+// need to be installed (or type-resolved) for DevCrew to build and run.
+const importOptional = async (specifier) => {
+    const dynamicSpecifier = specifier;
+    return (await import(dynamicSpecifier));
+};
+function sdkPackageName(backend) {
+    return backend === "local" ? "local" : HOST_SDK_PACKAGES[backend];
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sdkResolutionHint(backend, reason) {
+    const packageName = sdkPackageName(backend);
+    if (backend === "local") {
+        return reason;
+    }
+    return `${reason}. DevCrew apply mode requires ${packageName} to be resolvable from the ${DEVCREW_NPM_PACKAGE} package. Reinstall DevCrew with optional dependencies enabled, for example: npm install -g ${DEVCREW_NPM_PACKAGE} --include=optional`;
+}
+export async function checkHostSdkResolution(backend, deps = {}) {
+    const packageName = sdkPackageName(backend);
+    if (backend === "local") {
+        return { backend, packageName, available: true };
+    }
+    const loadModule = deps.loadModule ?? importOptional;
+    try {
+        await loadModule(packageName);
+        return { backend, packageName, available: true };
+    }
+    catch (error) {
+        return { backend, packageName, available: false, error: errorMessage(error) };
+    }
+}
+// --- Pure, testable contract helpers ---------------------------------------
+export function buildCodexThreadOptions(cwd, sandboxMode = "read-only") {
+    return { workingDirectory: cwd, skipGitRepoCheck: true, sandboxMode };
+}
+export function extractCodexText(turn) {
+    const text = typeof turn?.finalResponse === "string" ? turn.finalResponse.trim() : "";
+    if (!text) {
+        throw new Error("Codex SDK returned an empty finalResponse");
+    }
+    return text;
+}
+export function buildClaudeOptions(cwd, permissionMode = "plan", allowedTools = ["Read", "Grep", "Glob"]) {
+    // Read-only planning mode keeps roles from modifying the repository.
+    return { cwd, permissionMode, allowedTools };
+}
+export function extractClaudeResult(message) {
+    if (!message) {
+        throw new Error("Claude Agent SDK did not return a result message");
+    }
+    if (message.is_error || (message.subtype && message.subtype !== "success")) {
+        throw new Error(`Claude Agent SDK ended with subtype "${message.subtype ?? "unknown"}"`);
+    }
+    const text = typeof message.result === "string" ? message.result.trim() : "";
+    if (!text) {
+        throw new Error("Claude Agent SDK returned an empty result");
+    }
+    return text;
+}
+function roleCanApply(input) {
+    return input.executionMode === "apply" && (input.role === "implementer" || input.role === "tester");
+}
+function codexSandboxForRole(input) {
+    return roleCanApply(input) ? "workspace-write" : "read-only";
+}
+function claudeOptionsForRole(input) {
+    if (!roleCanApply(input)) {
+        return buildClaudeOptions(input.cwd);
+    }
+    const allowedTools = input.role === "implementer" ? ["Read", "Grep", "Glob", "Edit", "Write", "Bash"] : ["Read", "Grep", "Glob", "Bash"];
+    return buildClaudeOptions(input.cwd, "acceptEdits", allowedTools);
+}
+async function runWithCodex(input, prompt, loadModule) {
+    const mod = await loadModule(HOST_SDK_PACKAGES.codex);
+    const CodexClass = mod.Codex;
+    const codex = new CodexClass();
+    const thread = codex.startThread(buildCodexThreadOptions(input.cwd, codexSandboxForRole(input)));
+    const turn = await thread.run(prompt);
+    return extractCodexText(turn);
+}
+async function runWithClaude(input, prompt, loadModule) {
+    const mod = await loadModule(HOST_SDK_PACKAGES.claude);
+    const query = mod.query;
+    let resultMessage;
+    for await (const message of query({ prompt, options: claudeOptionsForRole(input) })) {
+        if (message?.type === "result") {
+            resultMessage = message;
+        }
+    }
+    return extractClaudeResult(resultMessage);
+}
+function fallbackResult(role, backend, title, summary) {
+    return {
+        role,
+        backend,
+        summary,
+        markdown: `# ${title}\n\n${summary}\n`,
+        usedFallback: true,
+    };
+}
+function shouldFailOnSdkError(input) {
+    return input.executionMode === "apply" && input.backend !== "local";
+}
+export async function runRole(input, deps = {}) {
+    const loadModule = deps.loadModule ?? importOptional;
+    const title = titleForPhase(input.phase);
+    const prompt = renderRolePrompt(input);
+    if (input.backend === "local") {
+        return fallbackResult(input.role, input.backend, title, `${input.role} prepared a deterministic ${title} because the local backend does not call an external SDK.`);
+    }
+    try {
+        const markdown = input.backend === "codex"
+            ? await runWithCodex(input, prompt, loadModule)
+            : await runWithClaude(input, prompt, loadModule);
+        assertRoleSections(input.role, markdown);
+        return {
+            role: input.role,
+            backend: input.backend,
+            summary: `${input.role} produced ${title} using the ${input.backend} SDK.`,
+            markdown,
+            usedFallback: false,
+        };
+    }
+    catch (error) {
+        const reason = errorMessage(error);
+        if (shouldFailOnSdkError(input)) {
+            if (error instanceof RoleOutputValidationError) {
+                throw new Error(`DevCrew apply mode rejected invalid ${input.role} SDK output: ${reason}`);
+            }
+            throw new Error(`Cannot run DevCrew apply mode with unavailable ${input.backend} SDK: ${sdkResolutionHint(input.backend, reason)}`);
+        }
+        const fallbackReason = error instanceof RoleOutputValidationError
+            ? `the ${input.backend} SDK output failed validation: ${reason}`
+            : `the ${input.backend} SDK was unavailable: ${reason}`;
+        return fallbackResult(input.role, input.backend, title, `${input.role} prepared a deterministic ${title} fallback because ${fallbackReason}`);
+    }
+}

package/dist/packages/cli/src/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { access, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { checkHostSdkResolution } from "../../adapters/src/index.js";
+import { DEVCREW_VERSION } from "../../core/src/index.js";
+import { initProject } from "../../plugins/src/index.js";
+import { runStdioServer } from "../../service/src/index.js";
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function usage() {
+    return `DevCrew ${DEVCREW_VERSION}\n\nUsage:\n  devcrew init [cwd]\n  devcrew serve --stdio\n  devcrew doctor [cwd]\n  devcrew validate [cwd]\n`;
+}
+async function doctor(cwd) {
+    const config = resolve(cwd, ".devcrew", "config.json");
+    const codex = resolve(cwd, "plugins", "devcrew-codex", ".codex-plugin", "plugin.json");
+    const claude = resolve(cwd, "plugins", "devcrew-claude", ".claude-plugin", "plugin.json");
+    const codexSdk = await checkHostSdkResolution("codex");
+    const claudeSdk = await checkHostSdkResolution("claude");
+    console.log(`Node: ${process.version}`);
+    console.log(`Config: ${(await exists(config)) ? "ok" : "missing"}`);
+    console.log(`Codex plugin: ${(await exists(codex)) ? "ok" : "missing"}`);
+    console.log(`Claude plugin: ${(await exists(claude)) ? "ok" : "missing"}`);
+    console.log(`Codex SDK (${codexSdk.packageName}): ${codexSdk.available ? "ok" : `missing - ${codexSdk.error}`}`);
+    console.log(`Claude SDK (${claudeSdk.packageName}): ${claudeSdk.available ? "ok" : `missing - ${claudeSdk.error}`}`);
+}
+async function validate(cwd) {
+    const configPath = resolve(cwd, ".devcrew", "config.json");
+    const raw = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || typeof parsed.workflow !== "object") {
+        throw new Error(`${configPath} is not a valid DevCrew config`);
+    }
+    console.log(`Validated ${configPath}`);
+}
+async function main(argv) {
+    const [command, maybeCwd, ...rest] = argv;
+    const cwd = resolve(maybeCwd && !maybeCwd.startsWith("--") ? maybeCwd : process.cwd());
+    if (!command || command === "--help" || command === "-h") {
+        console.log(usage());
+        return;
+    }
+    if (command === "init") {
+        const result = await initProject(cwd);
+        console.log(`Initialized DevCrew in ${cwd}`);
+        console.log(`Codex plugin: ${result.codex.path}`);
+        console.log(`Claude plugin: ${result.claude.path}`);
+        return;
+    }
+    if (command === "serve") {
+        if (!argv.includes("--stdio") && rest.length > 0) {
+            throw new Error(`Only stdio transport is supported in v${DEVCREW_VERSION}`);
+        }
+        runStdioServer();
+        return;
+    }
+    if (command === "doctor") {
+        await doctor(cwd);
+        return;
+    }
+    if (command === "validate") {
+        await validate(cwd);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}\n\n${usage()}`);
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/packages/core/src/active-run.js

@@ -0,0 +1,24 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { activeRunPath, ensureProjectDirectories } from "./paths.js";
+export async function setActiveRun(cwd, runId) {
+    await ensureProjectDirectories(cwd);
+    const active = {
+        runId,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeFile(activeRunPath(cwd), `${JSON.stringify(active, null, 2)}\n`, "utf8");
+    return active;
+}
+export async function getActiveRunId(cwd) {
+    try {
+        const raw = await readFile(activeRunPath(cwd), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.runId === "string" && parsed.runId.trim()) {
+            return parsed.runId.trim();
+        }
+    }
+    catch {
+        // Fall through to the explicit error below.
+    }
+    throw new Error("No active DevCrew run. Pass runId or start a workflow first.");
+}

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

@@ -0,0 +1,120 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { artifactPath } from "./paths.js";
+function headingForArtifact(name) {
+    return {
+        requirements: "Requirements",
+        architecture: "Architecture",
+        "implementation-plan": "Implementation Plan",
+        "implementation-review": "Implementation Review",
+        "test-report": "Test Report",
+        acceptance: "Acceptance",
+    }[name];
+}
+function standardsExcerpt(state) {
+    const excerpt = state.standards.combined.trim();
+    if (excerpt.length <= 1400) {
+        return excerpt;
+    }
+    return `${excerpt.slice(0, 1400).trim()}\n\n[Standards truncated in artifact. Full sources: ${state.standards.sources.join(", ")}]`;
+}
+function answerBlock(state) {
+    if (state.answers.length === 0) {
+        return "No requester answers have been recorded yet.";
+    }
+    return state.answers.map((answer, index) => `${index + 1}. ${answer.answer}`).join("\n");
+}
+function feedbackBlock(state) {
+    if (state.feedback.length === 0) {
+        return "No rejection feedback has been recorded.";
+    }
+    return state.feedback.map((feedback) => `- ${feedback.gate}: ${feedback.message}`).join("\n");
+}
+function workflowContextBlock(state) {
+    return `## Workflow Context\n\n### Requester Answers\n\n${answerBlock(state)}\n\n### Rejection Feedback\n\n${feedbackBlock(state)}\n`;
+}
+function changedFilesBlock(state) {
+    if (state.changedFiles.length === 0) {
+        return "No changed files were recorded.";
+    }
+    return state.changedFiles.map((file) => `- ${file}`).join("\n");
+}
+function verificationBlock(state) {
+    if (state.verification.length === 0) {
+        return "No verification commands have been executed.";
+    }
+    return state.verification
+        .map((result) => `### ${result.command}\n\nExit Code: ${result.exitCode}\n\nOutput:\n\n\`\`\`text\n${result.output || "(no output)"}\n\`\`\``)
+        .join("\n\n");
+}
+function lintResultsBlock(state) {
+    if (state.lintResults.length === 0) {
+        return "No lint or format commands have been executed.";
+    }
+    return state.lintResults
+        .map((result) => `### ${result.command}\n\nExit Code: ${result.exitCode}\n\nOutput:\n\n\`\`\`text\n${result.output || "(no output)"}\n\`\`\``)
+        .join("\n\n");
+}
+function implementationDiffBlock(state) {
+    const diff = state.implementationDiff.trim();
+    if (!diff) {
+        return "No implementation diff was captured. Review the changed files list and repository state manually.";
+    }
+    return `\`\`\`diff\n${diff}\n\`\`\``;
+}
+function architectureComplianceInputsBlock(state) {
+    const architectureArtifact = state.artifacts.architecture ? "present" : "missing";
+    const diffStatus = state.implementationDiff.trim() ? "present" : "missing";
+    return [
+        `- Architecture Artifact: ${architectureArtifact}${state.artifacts.architecture ? ` (${state.artifacts.architecture})` : ""}`,
+        `- Changed Files: ${state.changedFiles.length}`,
+        `- Captured Diff: ${diffStatus}`,
+    ].join("\n");
+}
+function architectureComplianceStatus(state) {
+    if (state.changedFiles.length === 0 && !state.implementationDiff.trim()) {
+        return "No implementation changes detected";
+    }
+    return "Needs Human Review";
+}
+export function renderArtifact(name, state) {
+    const title = headingForArtifact(name);
+    const common = `# ${title}\n\nRun: ${state.runId}\nMode: ${state.mode}\nExecution Mode: ${state.executionMode}\nHost: ${state.host}\nBackend: ${state.backend}\nRequest: ${state.request}\n\n`;
+    if (name === "requirements") {
+        return `${common}## Functional Scope\n\n### In Scope\n\n- Capture the requested outcome in user-facing terms.\n\n### Out of Scope\n\n- Make explicit what is intentionally excluded before implementation.\n\n## Users and Scenarios\n\n- Identify the primary users and their key scenarios.\n\n## Acceptance Criteria\n\n- Express each criterion as Given / When / Then so it stays testable.\n\n## Priorities\n\n- Classify each requirement as Must / Should / Could / Won't (MoSCoW).\n\n## Current Requester Answers\n\n${answerBlock(state)}\n\n## Discovered Standards\n\n${standardsExcerpt(state)}\n\n## Open Questions\n\n- Confirm primary users and success criteria.\n- Confirm scope boundaries and non-goals.\n- Confirm deployment or environment constraints.\n\n## Rejection Feedback\n\n${feedbackBlock(state)}\n`;
+    }
+    if (name === "architecture") {
+        return `${common}${workflowContextBlock(state)}\n## Technical Decisions\n\nFor each key decision record Decision, Options Considered, Choice, Rationale, and Trade-offs.\n\n- Decision: owns state transitions, gates, and MCP tool handlers via a workflow service.\n  - Options Considered: monolithic handler vs. layered service + adapters.\n  - Choice: layered workflow service with a host adapter and artifact writer.\n  - Rationale: keeps gate logic testable and host execution swappable.\n  - Trade-offs: more modules to wire, but clearer boundaries.\n\n## Interface Contracts\n\nFor each interface give the signature, request/response schema, error contract, and data model.\n\n- Host adapter: selects Codex or Claude execution based on host or config override.\n- Artifact writer: persists Markdown outputs under docs/devcrew for review.\n\n## Data Flow and Deployment\n\n- Record data flow, deployment expectations, and rollback considerations.\n- For greenfield workflows keep the first implementation small enough to ship and test end to end.\n\n## Architecture Review Checklist\n\n- Architecture traces directly to approved requirements.\n- Implementation can be tested without a live production integration.\n- Security and permission decisions remain delegated to the host agent runtime.\n`;
+    }
+    if (name === "implementation-plan") {
+        return `${common}${workflowContextBlock(state)}\n## Implementation Summary\n\nImplement the smallest code path that satisfies the approved architecture.\n\n## Implementation Tasks\n\n1. Update or create focused tests for the requested behavior.\n2. Implement the smallest code path that satisfies the approved architecture.\n3. Preserve discovered standards and existing repository conventions.\n4. Write or update user-facing docs for changed behavior.\n5. Run the project validation commands and capture evidence.\n\n## Recorded Changes\n\n${changedFilesBlock(state)}\n\n## Lint Results\n\n${lintResultsBlock(state)}\n\n## Code Review Criteria\n\n- Changes stay inside the approved scope.\n- Public interfaces match the architecture artifact.\n- Tests cover success, failure, and gate behavior where applicable.\n`;
+    }
+    if (name === "implementation-review") {
+        return `${common}${workflowContextBlock(state)}\n## Implementation Diff Review\n\n### Changed Files\n\n${changedFilesBlock(state)}\n\n### Captured Diff\n\n${implementationDiffBlock(state)}\n\n## Lint Results\n\n${lintResultsBlock(state)}\n\n## Architecture Compliance Inputs\n\n${architectureComplianceInputsBlock(state)}\n\n## Architecture Compliance Review\n\nStatus: ${architectureComplianceStatus(state)}\n\n- Confirm changed files map back to the approved architecture artifact.\n- Confirm public interfaces, data flow, and deployment assumptions remain consistent with the architecture.\n- Confirm implementation scope does not include unapproved requirements or unrelated refactors.\n- Record any mismatch as rejection feedback before approving the implementation gate.\n`;
+    }
+    if (name === "test-report") {
+        return `${common}${workflowContextBlock(state)}\n## Test Cases\n\nEnumerate cases as a table covering happy, edge, failure, and regression paths.\n\n| ID | Scenario | Type | Expected |\n| --- | --- | --- | --- |\n| TC-1 | Primary success path | happy | Behaves as specified |\n| TC-2 | Boundary input | edge | Handled without error |\n| TC-3 | Invalid input | failure | Fails safely with clear error |\n\n## Coverage\n\nRun the coverage command and report the coverage summary plus any gaps. Evidence is captured under Acceptance Evidence.\n\n## Acceptance Evidence\n\n${verificationBlock(state)}\n\n## Known Risks\n\n- Host SDK availability may vary by user environment.\n- Agent permissions are inherited from the host and must be reviewed there.\n`;
+    }
+    return `${common}${workflowContextBlock(state)}\n## Acceptance Summary\n\nThe requester approved requirements, architecture, implementation planning, and test reporting gates for this run.\n\n## Approved Gates\n\n${Object.entries(state.gates)
+        .map(([gate, status]) => `- ${gate}: ${status}`)
+        .join("\n")}\n`;
+}
+export async function writeArtifact(name, state) {
+    const path = artifactPath(state.cwd, state.runId, name);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, renderArtifact(name, state), "utf8");
+    return path;
+}
+export async function readArtifact(state, name) {
+    const path = state.artifacts[name];
+    if (!path) {
+        throw new Error(`Artifact ${name} has not been created for run ${state.runId}`);
+    }
+    const content = await readFile(path, "utf8");
+    return {
+        name,
+        path,
+        content,
+        summary: content.split("\n").slice(0, 8).join("\n"),
+    };
+}

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

@@ -0,0 +1,51 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import { configPath, ensureProjectDirectories } from "./paths.js";
+export const DEFAULT_CONFIG = {
+    version: 1,
+    defaultBackend: "host-preferred",
+    executionMode: "plan",
+    verifyCommands: [],
+    lintCommands: [],
+    coverageCommands: [],
+    workflow: {
+        gates: ["requirements", "architecture", "implementation", "testing"],
+        artifactDirectory: "docs/devcrew",
+    },
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureConfig(cwd) {
+    await ensureProjectDirectories(cwd);
+    const path = configPath(cwd);
+    if (!(await exists(path))) {
+        await writeFile(path, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`, "utf8");
+        return DEFAULT_CONFIG;
+    }
+    return readConfig(cwd);
+}
+export async function readConfig(cwd) {
+    const raw = await readFile(configPath(cwd), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) {
+        throw new Error("Unsupported .devcrew/config.json version");
+    }
+    return {
+        ...DEFAULT_CONFIG,
+        ...parsed,
+        executionMode: parsed.executionMode ?? "plan",
+        verifyCommands: Array.isArray(parsed.verifyCommands) ? parsed.verifyCommands : [],
+        lintCommands: Array.isArray(parsed.lintCommands) ? parsed.lintCommands : [],
+        coverageCommands: Array.isArray(parsed.coverageCommands) ? parsed.coverageCommands : [],
+        workflow: {
+            ...DEFAULT_CONFIG.workflow,
+            ...parsed.workflow,
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+export * from "./active-run.js";
+export * from "./artifacts.js";
+export * from "./config.js";
+export * from "./paths.js";
+export * from "./standards.js";
+export * from "./store.js";
+export * from "./types.js";
+export * from "./validation.js";
+export * from "./version.js";
+export * from "./verification.js";
+export * from "./workflow.js";

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

@@ -0,0 +1,51 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+export function devcrewDir(cwd) {
+    return join(cwd, ".devcrew");
+}
+export function runsDir(cwd) {
+    return join(devcrewDir(cwd), "runs");
+}
+export function runDir(cwd, runId) {
+    return join(runsDir(cwd), runId);
+}
+export function statePath(cwd, runId) {
+    return join(runDir(cwd, runId), "state.json");
+}
+export function configPath(cwd) {
+    return join(devcrewDir(cwd), "config.json");
+}
+export function activeRunPath(cwd) {
+    return join(devcrewDir(cwd), "active-run.json");
+}
+export function standardsPath(cwd) {
+    return join(devcrewDir(cwd), "standards.md");
+}
+export function docsRoot(cwd) {
+    return join(cwd, "docs", "devcrew");
+}
+export function docsRunDir(cwd, runId) {
+    return join(docsRoot(cwd), runId);
+}
+export function artifactPath(cwd, runId, artifact) {
+    const filenameByArtifact = {
+        requirements: "requirements.md",
+        architecture: "architecture.md",
+        "implementation-plan": "implementation-plan.md",
+        "implementation-review": "implementation-review.md",
+        "test-report": "test-report.md",
+        acceptance: "acceptance.md",
+    };
+    return join(docsRunDir(cwd, runId), filenameByArtifact[artifact]);
+}
+export async function ensureRunDirectories(cwd, runId) {
+    await mkdir(runDir(cwd, runId), { recursive: true });
+    await mkdir(docsRunDir(cwd, runId), { recursive: true });
+}
+export async function ensureProjectDirectories(cwd) {
+    await mkdir(devcrewDir(cwd), { recursive: true });
+    await mkdir(docsRoot(cwd), { recursive: true });
+}
+export function relativeArtifactMap(state) {
+    return state.artifacts;
+}

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

@@ -0,0 +1,61 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { standardsPath } from "./paths.js";
+import { readPackageJson } from "./verification.js";
+async function readIfExists(path) {
+    try {
+        await access(path);
+        return readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function section(path, content) {
+    return `## ${path}\n\n${content.trim()}\n`;
+}
+async function packageJsonSummary(cwd) {
+    const parsed = await readPackageJson(cwd);
+    if (!parsed) {
+        return undefined;
+    }
+    const scripts = Object.keys(parsed.scripts ?? {});
+    if (scripts.length === 0) {
+        return "package.json scripts: none";
+    }
+    return `package.json scripts: ${scripts.join(", ")}`;
+}
+export async function discoverStandards(cwd) {
+    const candidates = [
+        standardsPath(cwd),
+        join(cwd, "AGENTS.md"),
+        join(cwd, "CLAUDE.md"),
+        join(cwd, "README.md"),
+        join(cwd, "README"),
+        join(cwd, "pyproject.toml"),
+        join(cwd, "go.mod"),
+        join(cwd, "Cargo.toml"),
+    ];
+    const sources = [];
+    const sections = [];
+    for (const candidate of candidates) {
+        const content = await readIfExists(candidate);
+        if (content?.trim()) {
+            sources.push(candidate);
+            sections.push(section(candidate, content));
+        }
+    }
+    const packageSummary = await packageJsonSummary(cwd);
+    if (packageSummary) {
+        const packagePath = join(cwd, "package.json");
+        sources.push(packagePath);
+        sections.push(section(packagePath, packageSummary));
+    }
+    if (sections.length === 0) {
+        sections.push("No project standards were discovered. Follow the current repository style and ask before broad refactors.\n");
+    }
+    return {
+        sources,
+        combined: sections.join("\n"),
+    };
+}

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

@@ -0,0 +1,24 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { ensureRunDirectories, statePath } from "./paths.js";
+export async function saveState(state) {
+    state.updatedAt = new Date().toISOString();
+    await ensureRunDirectories(state.cwd, state.runId);
+    const target = statePath(state.cwd, state.runId);
+    const temp = join(dirname(target), `.state.${process.pid}.${Date.now()}.tmp`);
+    await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    await rename(temp, target);
+    return state;
+}
+export async function loadState(cwd, runId) {
+    const raw = await readFile(statePath(cwd, runId), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+        ...parsed,
+        executionMode: parsed.executionMode ?? "plan",
+        changedFiles: Array.isArray(parsed.changedFiles) ? parsed.changedFiles : [],
+        implementationDiff: typeof parsed.implementationDiff === "string" ? parsed.implementationDiff : "",
+        verification: Array.isArray(parsed.verification) ? parsed.verification : [],
+        lintResults: Array.isArray(parsed.lintResults) ? parsed.lintResults : [],
+    };
+}