@shenlee/devcrew 0.1.0

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

@@ -0,0 +1,376 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve as resolvePath } from "node:path";
+import { runRole } from "../../adapters/src/index.js";
+import { answerWorkflow, artifactForPhase, artifactPath, ARTIFACTS, discoverCoverageCommands, discoverLintCommands, discoverVerifyCommands, gateForPhase, getWorkflowStatus, readConfig, rejectWorkflow, renderArtifact, saveState, startWorkflow, } from "../../core/src/index.js";
+// Hard cap so a hung apply/verify command cannot block the serialized MCP loop.
+const COMMAND_TIMEOUT_MS = 300_000;
+function roleForPhase(phase) {
+    const roles = {
+        requirements: "pm",
+        architecture: "architect",
+        implementation: "implementer",
+        testing: "tester",
+    };
+    return roles[phase];
+}
+function conductorDecision(state, role, gate) {
+    const summary = `Conductor routed ${state.phase} phase to ${role} and prepared the ${gate} gate.`;
+    return {
+        role: "conductor",
+        backend: state.backend,
+        summary,
+        markdown: `# Conductor Decision\n\n${summary}\n`,
+        usedFallback: false,
+    };
+}
+function priorArtifactNamesForPhase(phase) {
+    const current = artifactForPhase(phase);
+    const currentIndex = ARTIFACTS.indexOf(current);
+    if (currentIndex <= 0) {
+        return [];
+    }
+    return ARTIFACTS.slice(0, currentIndex);
+}
+async function writeMarkdownArtifact(state, artifact, markdown) {
+    const path = artifactPath(state.cwd, state.runId, artifact);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, markdown, "utf8");
+    return path;
+}
+function now() {
+    return new Date().toISOString();
+}
+function fallbackNotice(result) {
+    if (!result.usedFallback) {
+        return "";
+    }
+    if (result.backend === "local") {
+        return `> DevCrew local fallback: this artifact uses the deterministic local planning template because the local backend does not call an external SDK.\n\n`;
+    }
+    const reason = result.summary.includes("output failed validation")
+        ? `the ${result.backend} SDK did not return a valid artifact`
+        : `the ${result.backend} SDK was unavailable`;
+    return `> DevCrew SDK fallback: this artifact uses the deterministic planning template because ${reason}.\n> Reason: ${result.summary}\n\n`;
+}
+async function readPriorArtifacts(state) {
+    const priorArtifacts = {};
+    for (const name of priorArtifactNamesForPhase(state.phase)) {
+        const path = state.artifacts[name];
+        if (!path) {
+            continue;
+        }
+        priorArtifacts[name] = await readFile(path, "utf8");
+    }
+    return priorArtifacts;
+}
+export async function runShellCommand(command, cwd, timeoutMs = COMMAND_TIMEOUT_MS) {
+    const startedAt = now();
+    return new Promise((resolveResult) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const chunks = [];
+        const maxOutputBytes = 64_000;
+        let collected = 0;
+        let timedOut = false;
+        let settled = false;
+        function collect(chunk) {
+            if (collected >= maxOutputBytes) {
+                return;
+            }
+            const slice = chunk.subarray(0, Math.max(0, maxOutputBytes - collected));
+            chunks.push(slice);
+            collected += slice.length;
+        }
+        const killTimer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
+        }, timeoutMs);
+        killTimer.unref();
+        function finish(result) {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(killTimer);
+            resolveResult(result);
+        }
+        child.stdout.on("data", collect);
+        child.stderr.on("data", collect);
+        child.on("error", (error) => {
+            finish({ command, exitCode: 1, output: error.message, startedAt, completedAt: now() });
+        });
+        child.on("close", (code) => {
+            const base = Buffer.concat(chunks).toString("utf8").replace(/\s+$/u, "");
+            const output = timedOut
+                ? `${base}\n[devcrew] command timed out after ${timeoutMs}ms`.trim()
+                : base;
+            finish({ command, exitCode: timedOut ? 124 : code ?? 1, output, startedAt, completedAt: now() });
+        });
+    });
+}
+async function runGit(args, cwd) {
+    return new Promise((resolveResult) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", () => resolveResult({ exitCode: 1, stdout: "" }));
+        child.on("close", (code) => resolveResult({ exitCode: code ?? 1, stdout: stdout || stderr }));
+    });
+}
+async function listChangedLines(cwd, options = {}) {
+    const result = await runShellCommand("git status --porcelain -uall", cwd, 30_000);
+    if (result.exitCode !== 0) {
+        if (options.requireGit) {
+            throw new Error("DevCrew apply mode requires a git repository so implementation changes can be reviewed and reverted.");
+        }
+        return [];
+    }
+    return result.output
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter(Boolean)
+        .filter((line) => {
+        const path = line.slice(3);
+        return !path.startsWith(".devcrew/") && !path.startsWith("docs/devcrew/");
+    });
+}
+async function assertCleanApplyWorkspace(cwd) {
+    const changedLines = await listChangedLines(cwd, { requireGit: true });
+    if (changedLines.length === 0) {
+        return;
+    }
+    const visibleLines = changedLines.slice(0, 20).join(", ");
+    const suffix = changedLines.length > 20 ? `, and ${changedLines.length - 20} more` : "";
+    throw new Error(`DevCrew apply mode requires a clean working tree before implementation. Commit, stash, or remove these files: ${visibleLines}${suffix}`);
+}
+async function collectImplementationDiff(cwd) {
+    const result = await runShellCommand("git diff --no-ext-diff --", cwd, 30_000);
+    if (result.exitCode !== 0) {
+        return "";
+    }
+    return result.output;
+}
+// Files attributable to this run are the porcelain lines that appeared (or
+// changed status) since the baseline captured before the role executed. This
+// keeps a user's pre-existing uncommitted edits out of the changed-files list.
+// The porcelain status prefix is preserved for review (?? = new, M = modified).
+export function changedSinceBaseline(baseline, current) {
+    const baselineLines = new Set(baseline);
+    return current.filter((line) => !baselineLines.has(line));
+}
+// Strip the two-character porcelain status plus its separating space. For
+// rename entries ("R  old -> new") the destination path is what remains
+// relevant, so keep only the post-arrow path when present.
+export function porcelainPath(line) {
+    const raw = line.slice(3).trim();
+    const arrow = raw.indexOf(" -> ");
+    return arrow >= 0 ? raw.slice(arrow + 4) : raw;
+}
+// Roll back implementer edits when an apply-mode gate is rejected.
+// Only the files this run introduced/changed are reverted, so unrelated work in
+// the repository is preserved. Tracked files are restored from HEAD; files that
+// did not exist in HEAD are deleted. Failures are surfaced to the MCP caller.
+export async function revertChangedFiles(cwd, changedFiles, deps = {}) {
+    const git = deps.runGit ?? runGit;
+    const removeFile = deps.removeFile ?? ((absolutePath) => rm(absolutePath, { force: true }));
+    for (const line of changedFiles) {
+        const file = porcelainPath(line);
+        if (!file) {
+            continue;
+        }
+        const tracked = await git(["cat-file", "-e", `HEAD:${file}`], cwd);
+        if (tracked.exitCode === 0) {
+            const restored = await git(["restore", "--source=HEAD", "--", file], cwd);
+            if (restored.exitCode !== 0) {
+                throw new Error(`Failed to restore ${file}: ${restored.stdout || "git restore failed"}`);
+            }
+        }
+        else {
+            try {
+                await removeFile(resolvePath(cwd, file));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to remove ${file}: ${message}`);
+            }
+        }
+    }
+}
+async function runCommands(commands, cwd) {
+    const results = [];
+    for (const command of commands) {
+        results.push(await runShellCommand(command, cwd));
+    }
+    return results;
+}
+function uniqueCommands(commands) {
+    const seen = new Set();
+    const unique = [];
+    for (const command of commands) {
+        if (seen.has(command)) {
+            continue;
+        }
+        seen.add(command);
+        unique.push(command);
+    }
+    return unique;
+}
+// Tester verification runs the normal verification path first, then coverage
+// as supplemental evidence. Configured commands win per category; otherwise
+// DevCrew discovers common project commands.
+async function runConfiguredVerification(state) {
+    const config = await readConfig(state.cwd);
+    const configuredVerify = config.verifyCommands.filter((command) => command.trim().length > 0);
+    const configuredCoverage = (config.coverageCommands ?? []).filter((command) => command.trim().length > 0);
+    const verifyCommands = configuredVerify.length > 0 ? configuredVerify : await discoverVerifyCommands(state.cwd);
+    const coverageCommands = configuredCoverage.length > 0 ? configuredCoverage : await discoverCoverageCommands(state.cwd);
+    const commands = uniqueCommands([...verifyCommands, ...coverageCommands]);
+    return runCommands(commands, state.cwd);
+}
+// Implementer apply runs lint/format/typecheck so reviewers see standards
+// compliance evidence. Configured lintCommands win, otherwise discover them.
+async function runConfiguredLint(state) {
+    const config = await readConfig(state.cwd);
+    const configuredLint = (config.lintCommands ?? []).filter((command) => command.trim().length > 0);
+    const commands = configuredLint.length > 0 ? configuredLint : await discoverLintCommands(state.cwd);
+    return runCommands(commands, state.cwd);
+}
+function changedFilesBlock(changedFiles) {
+    if (changedFiles.length === 0) {
+        return "No changed files were detected.";
+    }
+    return changedFiles.map((file) => `- ${file}`).join("\n");
+}
+function verificationBlock(results) {
+    if (results.length === 0) {
+        return "No verification commands were configured.";
+    }
+    return results
+        .map((result) => `### ${result.command}\n\nExit Code: ${result.exitCode}\n\nOutput:\n\n\`\`\`text\n${result.output || "(no output)"}\n\`\`\``)
+        .join("\n\n");
+}
+function lintBlock(results) {
+    if (results.length === 0) {
+        return "No lint or format commands were detected.";
+    }
+    return verificationBlock(results);
+}
+function appendExecutionSections(artifact, markdown, state) {
+    if (artifact === "implementation-plan") {
+        let next = markdown.trim();
+        if (!next.includes("## Recorded Changes")) {
+            next = `${next}\n\n## Recorded Changes\n\n${changedFilesBlock(state.changedFiles)}`;
+        }
+        if (!next.includes("## Lint Results")) {
+            next = `${next}\n\n## Lint Results\n\n${lintBlock(state.lintResults)}`;
+        }
+        return `${next}\n`;
+    }
+    if (artifact === "test-report" && !markdown.includes("## Acceptance Evidence")) {
+        return `${markdown.trim()}\n\n## Acceptance Evidence\n\n${verificationBlock(state.verification)}\n`;
+    }
+    return markdown;
+}
+async function runCurrentPhaseRole(state, runner = runRole) {
+    const gate = gateForPhase(state.phase);
+    const role = roleForPhase(state.phase);
+    if (!gate || !role) {
+        const artifact = artifactForPhase(state.phase);
+        const markdown = renderArtifact(artifact, state);
+        state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
+        state.phase = "complete";
+        state.status = "complete";
+        return saveState(state);
+    }
+    const artifact = artifactForPhase(state.phase);
+    const path = artifactPath(state.cwd, state.runId, artifact);
+    // Apply-mode implementation starts from a clean tree, so changed files after
+    // the role runs are attributable to the current DevCrew run.
+    const applyingImplementation = state.executionMode === "apply" && state.phase === "implementation";
+    const implementationBaseline = [];
+    if (applyingImplementation) {
+        await assertCleanApplyWorkspace(state.cwd);
+    }
+    state.roles.push(conductorDecision(state, role, gate));
+    const result = await runner({
+        backend: state.backend,
+        role,
+        phase: state.phase,
+        request: state.request,
+        mode: state.mode,
+        executionMode: state.executionMode,
+        cwd: state.cwd,
+        standards: state.standards.combined,
+        artifactPath: path,
+        answers: state.answers.map((entry) => entry.answer),
+        feedback: state.feedback.map((entry) => `${entry.gate}: ${entry.message}`),
+        priorArtifacts: await readPriorArtifacts(state),
+    });
+    if (applyingImplementation) {
+        state.changedFiles = changedSinceBaseline(implementationBaseline, await listChangedLines(state.cwd));
+        state.implementationDiff = await collectImplementationDiff(state.cwd);
+        state.lintResults = await runConfiguredLint(state);
+    }
+    if (state.executionMode === "apply" && state.phase === "testing") {
+        state.verification = await runConfiguredVerification(state);
+    }
+    // When the backend cannot run a real SDK we keep a single deterministic
+    // artifact source by rendering the rich phase template from the core layer.
+    const baseMarkdown = result.usedFallback ? `${fallbackNotice(result)}${renderArtifact(artifact, state)}` : result.markdown;
+    const markdown = appendExecutionSections(artifact, baseMarkdown, state);
+    state.roles.push({ ...result, markdown });
+    state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
+    if (artifact === "implementation-plan") {
+        state.artifacts["implementation-review"] = await writeMarkdownArtifact(state, "implementation-review", renderArtifact("implementation-review", state));
+    }
+    state.gates[gate] = "pending";
+    state.status = "awaiting_approval";
+    return saveState(state);
+}
+export async function startOrchestratedWorkflow(input, runner = runRole) {
+    const state = await startWorkflow(input, { skipArtifactWrite: true });
+    return runCurrentPhaseRole(state, runner);
+}
+export async function continueOrchestratedWorkflow(input, runner = runRole) {
+    const state = await getWorkflowStatus(input);
+    if (state.status === "awaiting_approval" || state.status === "awaiting_input" || state.status === "complete") {
+        return state;
+    }
+    return runCurrentPhaseRole(state, runner);
+}
+export async function rejectOrchestratedWorkflow(input) {
+    const before = await getWorkflowStatus(input);
+    const state = await rejectWorkflow(input);
+    // Roll back implementer edits when an apply-mode implementation gate is
+    // rejected so the next attempt starts from a clean working tree.
+    if (before.executionMode === "apply" &&
+        before.phase === "implementation" &&
+        before.changedFiles.length > 0) {
+        await revertChangedFiles(before.cwd, before.changedFiles);
+        state.changedFiles = [];
+        return saveState(state);
+    }
+    return state;
+}
+export async function answerOrchestratedWorkflow(input, runner = runRole) {
+    const state = await answerWorkflow(input, { skipArtifactWrite: true });
+    const gate = gateForPhase(state.phase);
+    const role = roleForPhase(state.phase);
+    if (!gate || !role) {
+        return state;
+    }
+    // Re-run the current phase role so the artifact reflects the new answer and
+    // any rejection feedback, instead of reverting to the static template.
+    return runCurrentPhaseRole(state, runner);
+}

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

@@ -0,0 +1,173 @@
+import { constants } from "node:fs";
+import { access, copyFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_CONFIG, DEVCREW_NPM_PACKAGE, DEVCREW_VERSION, ROLE_SECTIONS } from "../../core/src/index.js";
+async function writeJson(path, value) {
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+async function bundledAssetPath(name) {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(moduleDir, "..", "assets", name),
+        join(moduleDir, "..", "..", "..", "..", "packages", "plugins", "assets", name),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.R_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next layout: source tree first, compiled package second.
+        }
+    }
+    throw new Error(`Missing bundled DevCrew plugin asset: ${name}`);
+}
+async function writeCodexAssets(pluginRoot) {
+    const assetDir = join(pluginRoot, "assets");
+    await mkdir(assetDir, { recursive: true });
+    await copyFile(await bundledAssetPath("logo.png"), join(assetDir, "logo.png"));
+    await copyFile(await bundledAssetPath("composer-icon.png"), join(assetDir, "composer-icon.png"));
+}
+function roleExpectations(name) {
+    const sections = ROLE_SECTIONS[name];
+    if (!sections || sections.length === 0) {
+        return "";
+    }
+    return sections.map((s) => `- ${s.heading} (${s.description})`).join("\n");
+}
+async function writeRoleAgents(root, format) {
+    const roles = [
+        ["pm", "Product manager. Clarifies requirements, scope boundaries, success criteria, and requester approvals."],
+        ["architect", "technical architecture specialist. Designs implementation, deployment, interfaces, and review criteria."],
+        ["implementer", "Implementation engineer. Writes code according to approved architecture and discovered standards."],
+        ["tester", "Testing and acceptance specialist. Verifies functionality, regressions, and acceptance evidence."],
+    ];
+    if (format === "claude") {
+        const agentDir = join(root, "agents");
+        await mkdir(agentDir, { recursive: true });
+        for (const [name, description] of roles) {
+            await writeFile(join(agentDir, `${name}.md`), `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash\n---\n\nYou are the DevCrew ${name} role. ${description} Return concise Markdown and keep inherited host permissions.\n\nProduce these required sections:\n\n${roleExpectations(name)}\n`, "utf8");
+        }
+        return;
+    }
+    const agentDir = join(root, "agents");
+    await mkdir(agentDir, { recursive: true });
+    for (const [name, description] of roles) {
+        await writeFile(join(agentDir, `${name}.toml`), `name = "${name}"\ndescription = "${description}"\ndeveloper_instructions = """\nYou are the DevCrew ${name} role. ${description}\nReturn concise Markdown and keep inherited host permissions.\n\nProduce these required sections:\n${roleExpectations(name)}\n"""\n`, "utf8");
+    }
+}
+function entrySkill() {
+    return `---\nname: devcrew\ndescription: Run the DevCrew PM -> architecture -> implementation -> testing workflow. Use when the user asks for structured feature or product development, requirements clarification, architecture review, implementation planning, testing acceptance, or Chinese requests such as 完整研发流程, 需求澄清, 产品经理, 架构师, 开发测试流程.\n---\n\nUse the DevCrew MCP tools to manage the workflow:\n\n1. Start with \`devcrew_start\` using the current repository cwd, mode, request, and optional executionMode. Host is inferred from the plugin's \`DEVCREW_HOST\`; pass host only for an explicit override. Omit executionMode unless the requester explicitly asks DevCrew to apply changes; the default safe mode is \`plan\`.\n2. After start, DevCrew records the active run for this repository. For follow-up tools, omit runId unless you need to target a different run explicitly.\n3. Use \`executionMode: "apply"\` only when the requester explicitly wants DevCrew to write code or run validation commands. This still inherits host sandbox, approval, and tool permissions.\n4. Use \`devcrew_status\` to show the current phase and pending gate.\n5. Use \`devcrew_answer\` when the requester gives clarification.\n6. Use \`devcrew_approve\` or \`devcrew_reject\` for each gate.\n7. Use \`devcrew_continue\` after approvals. This executes the next phase role, writes the phase artifact, and opens the next gate. The implementation phase also writes \`implementation-review\` for diff and architecture compliance review.\n8. Use \`devcrew_artifact\` to read generated requirements, architecture, implementation-plan, implementation-review, test-report, or acceptance files.\n\nDo not bypass host sandbox, approval, or tool permissions.\n`;
+}
+function npmPackageSpecifier() {
+    return `${DEVCREW_NPM_PACKAGE}@${DEVCREW_VERSION}`;
+}
+export async function generateCodexPlugin(root) {
+    const pluginRoot = join(root, "plugins", "devcrew-codex");
+    await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
+    await mkdir(join(pluginRoot, "skills", "devcrew"), { recursive: true });
+    await writeCodexAssets(pluginRoot);
+    await writeJson(join(pluginRoot, ".codex-plugin", "plugin.json"), {
+        name: "devcrew",
+        version: DEVCREW_VERSION,
+        description: "DevCrew gated multi-role workflow service for Codex.",
+        author: {
+            name: "DevCrew Contributors",
+            url: "https://github.com/lishen802/devcrew",
+        },
+        homepage: "https://github.com/lishen802/devcrew#readme",
+        repository: "https://github.com/lishen802/devcrew",
+        license: "Apache-2.0",
+        keywords: ["codex", "agents", "workflow", "mcp", "skills"],
+        skills: "./skills/",
+        mcpServers: "./.mcp.json",
+        interface: {
+            displayName: "DevCrew",
+            shortDescription: "Run gated PM, architecture, implementation, and testing workflows.",
+            longDescription: "DevCrew helps Codex run feature and product development through explicit requirements, architecture, implementation planning, and testing gates.",
+            developerName: "DevCrew Contributors",
+            category: "Productivity",
+            capabilities: ["Interactive", "Write"],
+            websiteURL: "https://github.com/lishen802/devcrew",
+            defaultPrompt: [
+                "Use DevCrew to plan this feature.",
+                "Use DevCrew to build this product.",
+                "Use DevCrew to review this implementation plan.",
+            ],
+            brandColor: "#2563EB",
+            composerIcon: "./assets/composer-icon.png",
+            logo: "./assets/logo.png",
+        },
+    });
+    await writeFile(join(pluginRoot, "skills", "devcrew", "SKILL.md"), entrySkill(), "utf8");
+    await writeJson(join(pluginRoot, ".mcp.json"), {
+        mcpServers: {
+            devcrew: {
+                command: "npx",
+                args: ["-y", npmPackageSpecifier(), "serve", "--stdio"],
+                env: { DEVCREW_HOST: "codex" },
+            },
+        },
+    });
+    await writeRoleAgents(pluginRoot, "codex");
+    return { name: "devcrew", path: pluginRoot };
+}
+export async function generateCodexMarketplace(root) {
+    const marketplacePath = join(root, ".agents", "plugins", "marketplace.json");
+    await mkdir(join(root, ".agents", "plugins"), { recursive: true });
+    await writeJson(marketplacePath, {
+        name: "devcrew",
+        interface: {
+            displayName: "DevCrew",
+        },
+        plugins: [
+            {
+                name: "devcrew",
+                source: {
+                    source: "local",
+                    path: "./plugins/devcrew-codex",
+                },
+                policy: {
+                    installation: "AVAILABLE",
+                    authentication: "ON_INSTALL",
+                },
+                category: "Productivity",
+            },
+        ],
+    });
+    return { name: "devcrew", path: marketplacePath };
+}
+export async function generateClaudePlugin(root) {
+    const pluginRoot = join(root, "plugins", "devcrew-claude");
+    await mkdir(join(pluginRoot, ".claude-plugin"), { recursive: true });
+    await mkdir(join(pluginRoot, "skills", "devcrew"), { recursive: true });
+    await writeJson(join(pluginRoot, ".claude-plugin", "plugin.json"), {
+        name: "devcrew",
+        description: "DevCrew gated multi-role workflow service for Claude Code.",
+        version: DEVCREW_VERSION,
+        author: { name: "DevCrew Contributors" },
+    });
+    await writeFile(join(pluginRoot, "skills", "devcrew", "SKILL.md"), entrySkill(), "utf8");
+    await writeJson(join(pluginRoot, ".mcp.json"), {
+        mcpServers: {
+            devcrew: {
+                command: "npx",
+                args: ["-y", npmPackageSpecifier(), "serve", "--stdio"],
+                env: { DEVCREW_HOST: "claude" },
+            },
+        },
+    });
+    await writeRoleAgents(pluginRoot, "claude");
+    return { name: "devcrew", path: pluginRoot };
+}
+export async function initProject(root) {
+    await mkdir(join(root, ".devcrew"), { recursive: true });
+    await mkdir(join(root, "docs", "devcrew"), { recursive: true });
+    await writeJson(join(root, ".devcrew", "config.json"), DEFAULT_CONFIG);
+    await writeFile(join(root, ".devcrew", "standards.md"), "# DevCrew Standards\n\nAdd project-specific coding, testing, documentation, and deployment rules here.\n", "utf8");
+    const codex = await generateCodexPlugin(root);
+    await generateCodexMarketplace(root);
+    const claude = await generateClaudePlugin(root);
+    return { codex, claude };
+}

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

@@ -0,0 +1,2 @@
+export * from "./stdio.js";
+export * from "./tools.js";

package/dist/packages/service/src/stdio.js

@@ -0,0 +1,100 @@
+import { callDevCrewTool, listDevCrewTools } from "./tools.js";
+import { DEVCREW_VERSION } from "../../core/src/index.js";
+function writeJson(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+async function handleRequest(request, write) {
+    if (request.method === "notifications/initialized") {
+        return;
+    }
+    if (request.id === undefined || request.id === null) {
+        return;
+    }
+    try {
+        if (request.method === "initialize") {
+            write({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    protocolVersion: "2025-03-26",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "devcrew", version: DEVCREW_VERSION },
+                },
+            });
+            return;
+        }
+        if (request.method === "tools/list") {
+            write({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: { tools: listDevCrewTools() },
+            });
+            return;
+        }
+        if (request.method === "tools/call") {
+            const params = request.params ?? {};
+            const name = params.name;
+            if (typeof name !== "string") {
+                throw new Error("tools/call params.name must be a string");
+            }
+            const result = await callDevCrewTool(name, (params.arguments ?? {}));
+            write({
+                jsonrpc: "2.0",
+                id: request.id,
+                result,
+            });
+            return;
+        }
+        throw new Error(`Unsupported JSON-RPC method: ${request.method ?? "unknown"}`);
+    }
+    catch (error) {
+        write({
+            jsonrpc: "2.0",
+            id: request.id,
+            error: {
+                code: -32000,
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+export function createStdioLineProcessor(write = writeJson, handler = (request) => handleRequest(request, write)) {
+    let queue = Promise.resolve();
+    return async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return queue;
+        }
+        let request;
+        try {
+            request = JSON.parse(trimmed);
+        }
+        catch {
+            write({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            return queue;
+        }
+        queue = queue.then(() => handler(request));
+        return queue;
+    };
+}
+export function runStdioServer() {
+    let buffer = "";
+    const processLine = createStdioLineProcessor();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            void processLine(trimmed);
+        }
+    });
+}