planforge 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,68 @@
+/**
+ * planforge config - show or suggest planforge.json
+ */
+import fs from "fs-extra";
+import { resolve } from "path";
+import { getProjectRoot } from "../utils/paths.js";
+import { checkClaude } from "../providers/claude.js";
+import { checkCodex } from "../providers/codex.js";
+import { getPresetForProviders, } from "../config/presets.js";
+export function formatRole(config, role) {
+    const r = config[role];
+    const parts = [r.provider, r.model];
+    if (r.effort)
+        parts.push(`effort:${r.effort}`);
+    if (r.reasoning)
+        parts.push(`reasoning:${r.reasoning}`);
+    return parts.join(" / ");
+}
+export function configEqual(a, b) {
+    return (JSON.stringify(a.planner) === JSON.stringify(b.planner) &&
+        JSON.stringify(a.implementer) === JSON.stringify(b.implementer));
+}
+export async function runConfigShow(_args) {
+    const projectRoot = getProjectRoot();
+    const configPath = resolve(projectRoot, "planforge.json");
+    if (!(await fs.pathExists(configPath))) {
+        console.log("Run planforge init first.");
+        return;
+    }
+    const content = await fs.readFile(configPath, "utf-8");
+    console.log(content);
+}
+export async function runConfigSuggest(args) {
+    const apply = args.includes("--apply");
+    const projectRoot = getProjectRoot();
+    const configPath = resolve(projectRoot, "planforge.json");
+    const hasClaude = checkClaude();
+    const hasCodex = checkCodex();
+    const suggested = getPresetForProviders(hasClaude, hasCodex);
+    if (!(await fs.pathExists(configPath))) {
+        console.log("No planforge.json found. Suggested config for your installed providers:\n");
+        console.log(JSON.stringify(suggested, null, 2));
+        if (apply) {
+            await fs.writeJson(configPath, suggested, { spaces: 2 });
+            console.log("\nCreated planforge.json");
+        }
+        return;
+    }
+    const current = (await fs.readJson(configPath));
+    if (configEqual(current, suggested)) {
+        console.log("Your planforge.json already matches the recommended config for your providers.");
+        return;
+    }
+    console.log("\nConfig comparison (installed providers: Claude " + (hasClaude ? "yes" : "no") + ", Codex " + (hasCodex ? "yes" : "no") + ")\n");
+    console.log("  Current:   planner   " + formatRole(current, "planner"));
+    console.log("             implementer " + formatRole(current, "implementer"));
+    console.log("");
+    console.log("  Suggested: planner   " + formatRole(suggested, "planner"));
+    console.log("             implementer " + formatRole(suggested, "implementer"));
+    console.log("");
+    if (apply) {
+        await fs.writeJson(configPath, suggested, { spaces: 2 });
+        console.log("Updated planforge.json to suggested config.");
+    }
+    else {
+        console.log("Run planforge config suggest --apply to update planforge.json.");
+    }
+}

package/dist/commands/doctor.js

@@ -0,0 +1,84 @@
+/**
+ * planforge doctor - check environment and providers
+ */
+import fs from "fs-extra";
+import { resolve } from "path";
+import { getProjectRoot, getPlansDir } from "../utils/paths.js";
+import { checkClaude } from "../providers/claude.js";
+import { checkCodex } from "../providers/codex.js";
+function statusSymbol(s) {
+    switch (s) {
+        case "ok":
+            return "[OK]";
+        case "warn":
+            return "[WARN]";
+        case "error":
+            return "[ERROR]";
+    }
+}
+export async function runDoctor(_args) {
+    const cwd = process.cwd();
+    const projectRoot = getProjectRoot(cwd);
+    const plansDir = getPlansDir(projectRoot);
+    const checks = [];
+    const hasClaude = checkClaude();
+    const hasCodex = checkCodex();
+    checks.push({
+        name: "Claude CLI",
+        status: hasClaude ? "ok" : "warn",
+        message: hasClaude ? "available" : "not found (planning /p will be limited)",
+    });
+    checks.push({
+        name: "Codex CLI",
+        status: hasCodex ? "ok" : "warn",
+        message: hasCodex ? "available" : "not found (implementation /i will be limited)",
+    });
+    const claudeMdPath = resolve(projectRoot, "CLAUDE.md");
+    const hasClaudeMd = await fs.pathExists(claudeMdPath);
+    checks.push({
+        name: "CLAUDE.md",
+        status: hasClaudeMd ? "ok" : (hasClaude ? "warn" : "ok"),
+        message: hasClaudeMd ? "exists" : (hasClaude ? "missing (run claude /init)" : "n/a"),
+    });
+    const agentsPath = resolve(projectRoot, "AGENTS.md");
+    const hasAgentsMd = await fs.pathExists(agentsPath);
+    checks.push({
+        name: "AGENTS.md",
+        status: hasAgentsMd ? "ok" : (hasCodex ? "warn" : "ok"),
+        message: hasAgentsMd ? "exists" : (hasCodex ? "missing" : "n/a"),
+    });
+    const configPath = resolve(projectRoot, "planforge.json");
+    const hasConfig = await fs.pathExists(configPath);
+    checks.push({
+        name: "planforge.json",
+        status: hasConfig ? "ok" : "error",
+        message: hasConfig ? "exists" : "missing (run planforge init)",
+    });
+    const hasPlansDir = await fs.pathExists(plansDir);
+    checks.push({
+        name: ".cursor/plans",
+        status: hasPlansDir ? "ok" : "error",
+        message: hasPlansDir ? "exists" : "missing (run planforge init)",
+    });
+    console.log("\nPlanForge doctor");
+    console.log("  ------------------------------");
+    console.log("");
+    const maxName = Math.max(...checks.map((c) => c.name.length), 16);
+    for (const c of checks) {
+        const sym = statusSymbol(c.status);
+        const padded = c.name.padEnd(maxName);
+        console.log(`  ${sym}  ${padded}  ${c.message}`);
+    }
+    console.log("");
+    if (!hasClaude || !hasCodex) {
+        console.log("  Run planforge init to install missing providers.");
+    }
+    if (hasClaude || hasCodex) {
+        console.log("  Run planforge config suggest to see recommended config for your providers.");
+    }
+    console.log("");
+    const hasError = checks.some((c) => c.status === "error");
+    if (hasError) {
+        process.exit(1);
+    }
+}

package/dist/commands/implement.js

@@ -0,0 +1,204 @@
+/**
+ * planforge implement <prompt> - run implementation via configured implementer provider
+ */
+import fs from "fs-extra";
+import { spawnSync } from "child_process";
+import { resolve, dirname } from "path";
+import { readFile } from "fs/promises";
+import { getProjectRoot } from "../utils/paths.js";
+import { getActivePlanPath } from "../utils/active-plan.js";
+import { parseFilesFromPlan } from "../utils/plan-files.js";
+import { getProjectContext } from "../utils/project-context.js";
+import { loadConfig } from "../config/load.js";
+import { getImplementerRunner } from "../providers/registry.js";
+const MAX_CODE_CONTEXT_CHARS = 12000;
+const MAX_RECENT_COMMITS_PER_FILE_CHARS = 400;
+const MAX_RECENT_COMMITS_PER_FILE_COUNT = 5;
+/** Extract (relative path, content) from implement output: lines like "### 1) `path/to/file`" followed by a fenced code block. */
+function extractFilesFromOutput(text) {
+    const files = [];
+    // Match: optional "### N) " then `path` then optional whitespace/newlines then ```lang? newline content ```
+    const blockRe = /(?:###\s*\d+\)\s*)?`([^`]+)`\s*[\r\n]+\s*```[\w]*\r?\n([\s\S]*?)```/g;
+    let m;
+    while ((m = blockRe.exec(text)) !== null) {
+        const rawPath = m[1].trim().replace(/\\/g, "/").replace(/^\//, "");
+        if (!rawPath || rawPath.includes(".."))
+            continue;
+        const content = m[2].replace(/\r\n/g, "\n").trimEnd();
+        files.push({ path: rawPath, content });
+    }
+    return files;
+}
+async function resolveContext(opts, cwd) {
+    if (!opts)
+        return undefined;
+    const parts = [];
+    if (opts.contextFile) {
+        const absPath = resolve(cwd, opts.contextFile);
+        try {
+            const content = await readFile(absPath, "utf-8");
+            if (content.trim())
+                parts.push(content.trim());
+        }
+        catch (err) {
+            console.error("Failed to read context file:", err.message);
+            process.exit(1);
+        }
+    }
+    if (opts.context?.trim())
+        parts.push(opts.context.trim());
+    if (parts.length === 0)
+        return undefined;
+    return parts.join("\n\n");
+}
+/** True if path looks like a glob (contains * or **). */
+function isGlob(path) {
+    return path.includes("*");
+}
+/** Build codeContext string from filesToChange (non-glob paths only), capped in total size. */
+async function buildCodeContext(projectRoot, filesToChange) {
+    const root = resolve(projectRoot);
+    const parts = [];
+    let total = 0;
+    for (const rel of filesToChange) {
+        if (isGlob(rel) || total >= MAX_CODE_CONTEXT_CHARS)
+            continue;
+        const abs = resolve(root, rel);
+        if (!abs.startsWith(root))
+            continue;
+        try {
+            const content = await readFile(abs, "utf-8");
+            const block = `### \`${rel}\`\n\`\`\`\n${content}\n\`\`\`\n`;
+            if (total + block.length > MAX_CODE_CONTEXT_CHARS) {
+                const remaining = MAX_CODE_CONTEXT_CHARS - total - 50;
+                if (remaining > 0) {
+                    parts.push(`### \`${rel}\`\n\`\`\`\n${content.slice(0, remaining)}\n...(truncated)\n\`\`\`\n`);
+                }
+                break;
+            }
+            parts.push(block);
+            total += block.length;
+        }
+        catch {
+            /* skip unreadable or binary */
+        }
+    }
+    if (parts.length === 0)
+        return undefined;
+    return parts.join("\n");
+}
+/** Run git log --oneline -n 1 for a path. Returns one-line message or null. */
+function runGitLogOneline(projectRoot, relPath) {
+    try {
+        const result = spawnSync("git", ["log", "--oneline", "-n", "1", "--", relPath], {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (result.status !== 0)
+            return null;
+        return (result.stdout ?? "").trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Build "Recent commit (per file)" string from filesToChange (non-glob, up to 5 files), capped at 400 chars. */
+function buildRecentCommitsForFiles(projectRoot, filesToChange) {
+    const root = resolve(projectRoot);
+    const lines = [];
+    let count = 0;
+    for (const rel of filesToChange) {
+        if (count >= MAX_RECENT_COMMITS_PER_FILE_COUNT || isGlob(rel))
+            continue;
+        const abs = resolve(root, rel);
+        if (!abs.startsWith(root))
+            continue;
+        const msg = runGitLogOneline(projectRoot, rel);
+        if (msg) {
+            lines.push(`${rel}: ${msg}`);
+            count++;
+        }
+    }
+    if (lines.length === 0)
+        return undefined;
+    let out = lines.join("\n");
+    if (out.length > MAX_RECENT_COMMITS_PER_FILE_CHARS) {
+        out = out.slice(0, MAX_RECENT_COMMITS_PER_FILE_CHARS) + "\n...(truncated)";
+    }
+    return out;
+}
+export async function runImplement(args, opts) {
+    const prompt = args.join(" ").trim();
+    if (!prompt) {
+        console.error("Usage: planforge implement <prompt>");
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const projectRoot = getProjectRoot(cwd);
+    const context = await resolveContext(opts, cwd);
+    let planContent;
+    if (opts?.planFile) {
+        const absPlan = resolve(cwd, opts.planFile);
+        try {
+            planContent = await readFile(absPlan, "utf-8");
+        }
+        catch (err) {
+            console.error("Failed to read plan file:", err.message);
+            process.exit(1);
+        }
+    }
+    else {
+        const activePath = getActivePlanPath(projectRoot);
+        if (activePath) {
+            try {
+                planContent = await readFile(activePath, "utf-8");
+            }
+            catch {
+                /* skip plan if unreadable */
+            }
+        }
+    }
+    const config = await loadConfig(projectRoot);
+    const runner = getImplementerRunner(config.implementer.provider);
+    if (!runner) {
+        console.error(`Unknown implementer provider: ${config.implementer.provider}. Check planforge.json.`);
+        process.exit(1);
+    }
+    if (!runner.check()) {
+        console.error(`${config.implementer.provider} CLI not found. Install the provider CLI to use planforge implement.`);
+        process.exit(1);
+    }
+    const filesToChange = opts?.files?.length ? opts.files : parseFilesFromPlan(planContent);
+    const codeContext = filesToChange.length > 0 ? await buildCodeContext(projectRoot, filesToChange) : undefined;
+    const projectContext = getProjectContext(projectRoot);
+    const recentCommitsPerFile = filesToChange.length > 0 ? buildRecentCommitsForFiles(projectRoot, filesToChange) : undefined;
+    try {
+        const result = await runner.runImplement(prompt, {
+            cwd: projectRoot,
+            context,
+            planContent,
+            filesToChange: filesToChange.length > 0 ? filesToChange : undefined,
+            codeContext,
+            projectContext,
+            recentCommitsPerFile,
+        });
+        const extracted = extractFilesFromOutput(result);
+        const root = resolve(projectRoot);
+        if (extracted.length > 0) {
+            for (const { path: relPath, content } of extracted) {
+                const absPath = resolve(root, relPath);
+                if (!absPath.startsWith(root))
+                    continue;
+                await fs.ensureDir(dirname(absPath));
+                await fs.writeFile(absPath, content, "utf-8");
+                console.log("Written:", relPath);
+            }
+        }
+        // Result was already streamed to terminal by the provider
+    }
+    catch (err) {
+        console.error("Implement failed:", err.message);
+        process.exit(1);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,267 @@
+/**
+ * planforge init - detect providers, install slash commands, create .cursor/plans
+ */
+import * as readline from "readline";
+import { spawnSync } from "child_process";
+import fs from "fs-extra";
+import { resolve } from "path";
+import { getProjectRoot, getPlansDir } from "../utils/paths.js";
+import { checkClaude, CLIENT_NPM_PACKAGE as CLAUDE_PKG } from "../providers/claude.js";
+import { checkCodex, CLIENT_NPM_PACKAGE as CODEX_PKG } from "../providers/codex.js";
+import { runCommand, runCommandLive } from "../utils/shell.js";
+import { installTemplates } from "../templates/install.js";
+import { getPresetForProviders } from "../config/presets.js";
+import { formatRole, configEqual } from "./config.js";
+const DEFAULT_AGENTS_MD = `# AGENTS.md
+
+Codex/OpenAI agent context for this project.
+Customize this file to give the implementer (/i) relevant project context.
+`;
+const DEFAULT_CLAUDE_MD = `# CLAUDE.md
+
+Claude project context. Run 'claude /init' after signing in, or edit this file.
+`;
+function ask(question, defaultVal) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const def = defaultVal ? ` (default: ${defaultVal})` : "";
+    return new Promise((resolvePromise) => {
+        rl.question(question + def + ": ", (answer) => {
+            rl.close();
+            resolvePromise((answer.trim() || defaultVal));
+        });
+    });
+}
+/**
+ * First prompt: install one missing provider or no. Returns "no" when non-TTY.
+ */
+async function promptFirstProvider(hasClaude, hasCodex) {
+    if (!process.stdin.isTTY) {
+        return "no";
+    }
+    console.log("\nPlanForge init - provider check\n");
+    console.log(`  Claude CLI   ${hasClaude ? "installed" : "not found"}  (recommended for /p planning)`);
+    console.log(`  Codex CLI    ${hasCodex ? "installed" : "not found"}  (recommended for /i implementation)`);
+    console.log("");
+    if (hasClaude && !hasCodex) {
+        console.log("Install Codex?");
+        console.log("  (1) Yes   (2) No");
+        const raw = await ask("Choice", "2");
+        const n = raw === "" ? 2 : parseInt(raw, 10);
+        return n === 1 ? "codex" : "no";
+    }
+    if (!hasClaude && hasCodex) {
+        console.log("Install Claude?");
+        console.log("  (1) Yes   (2) No");
+        const raw = await ask("Choice", "2");
+        const n = raw === "" ? 2 : parseInt(raw, 10);
+        return n === 1 ? "claude" : "no";
+    }
+    if (!hasClaude && !hasCodex) {
+        console.log("Which one to install first?");
+        console.log(`  1) Claude  (install ${CLAUDE_PKG})`);
+        console.log(`  2) Codex   (install ${CODEX_PKG})`);
+        console.log("");
+        const raw = await ask("Choice [1-2]", "1");
+        const n = raw === "" ? 1 : parseInt(raw, 10);
+        return n === 2 ? "codex" : "claude";
+    }
+    return "no";
+}
+function installProviderPackage(pkg) {
+    const ok = runCommandLive("npm", ["install", "-g", pkg]);
+    if (!ok) {
+        console.warn("Warning: npm install -g", pkg, "failed.");
+    }
+    return ok;
+}
+function formatRoleModel(config, role) {
+    const r = config[role];
+    let s = `${r.provider} / ${r.model}`;
+    if (r.reasoning)
+        s += ` (reasoning: ${r.reasoning})`;
+    if (r.effort)
+        s += ` (effort: ${r.effort})`;
+    return s;
+}
+/** Draw Complete UI box with title and /p, /i model lines. Uses preset for current providers so the box reflects recommended config. */
+function showCompleteBox(hasClaude, hasCodex, title) {
+    const config = getPresetForProviders(hasClaude, hasCodex);
+    const pLine = `  /p (planning)     : ${formatRoleModel(config, "planner")}`;
+    const iLine = `  /i (implementation): ${formatRoleModel(config, "implementer")}`;
+    const lines = [title, pLine, iLine];
+    const width = Math.max(...lines.map((s) => s.length), 40);
+    const top = "+" + "-".repeat(width + 2) + "+";
+    const bottom = "+" + "-".repeat(width + 2) + "+";
+    console.log("");
+    console.log(top);
+    for (const line of lines) {
+        console.log("| " + line.padEnd(width) + " |");
+    }
+    console.log(bottom);
+    console.log("");
+}
+/** After box: install the other provider or finish. Returns true if we should set finishedWithCodexOnly and show guide. */
+async function promptInstallOtherAfterBox(hasClaude, hasCodex) {
+    if (!process.stdin.isTTY || (hasClaude && hasCodex)) {
+        return "finish";
+    }
+    const other = !hasClaude ? "Claude" : "Codex";
+    console.log(`Install ${other} too?`);
+    console.log("  (1) Yes   (2) No, finish");
+    console.log("");
+    const raw = await ask("Choice [1-2]", "2");
+    const n = raw === "" ? 2 : parseInt(raw, 10);
+    return n === 1 ? "install_other" : "finish";
+}
+export async function runInit(args) {
+    const skipProviderInstall = args.includes("--skip-provider-install");
+    const cwd = process.cwd();
+    const projectRoot = getProjectRoot(cwd);
+    try {
+        let hasClaude = checkClaude();
+        let hasCodex = checkCodex();
+        let justInstalledClaude = false;
+        let installedClaudeThisRun = false;
+        let installedCodexThisRun = false;
+        let finishedWithCodexOnly = false;
+        let showGuideAtEnd = false;
+        if (!skipProviderInstall && (!hasClaude || !hasCodex)) {
+            const first = await promptFirstProvider(hasClaude, hasCodex);
+            if (first !== "no") {
+                if (first === "claude" && !hasClaude) {
+                    justInstalledClaude = installProviderPackage(CLAUDE_PKG);
+                    hasClaude = checkClaude();
+                    installedClaudeThisRun = true;
+                }
+                else if (first === "codex" && !hasCodex) {
+                    installProviderPackage(CODEX_PKG);
+                    hasCodex = checkCodex();
+                    installedCodexThisRun = true;
+                }
+            }
+        }
+        if (hasCodex && installedCodexThisRun && process.stdin.isTTY) {
+            console.log("\nCodex CLI was just installed. You'll be switched to Codex to sign in. Exit with Ctrl+C when done.\n");
+            spawnSync("codex", [], { stdio: "inherit", cwd: projectRoot, shell: true });
+        }
+        if (hasClaude && justInstalledClaude && process.stdin.isTTY) {
+            console.log("\nClaude CLI was just installed. You'll be switched to Claude to sign in or complete setup. Exit Claude when done.\n");
+            spawnSync("claude", [], { stdio: "inherit", cwd: projectRoot, shell: true });
+        }
+        if (installedCodexThisRun || installedClaudeThisRun) {
+            const boxTitle = hasClaude && hasCodex
+                ? "Both providers are ready."
+                : hasCodex
+                    ? "Complete. Codex is ready."
+                    : "Complete. Claude is ready.";
+            showCompleteBox(hasClaude, hasCodex, boxTitle);
+            const nextAfterBox = await promptInstallOtherAfterBox(hasClaude, hasCodex);
+            if (nextAfterBox === "finish") {
+                if (hasCodex && !hasClaude) {
+                    finishedWithCodexOnly = true;
+                }
+                if (!hasClaude || !hasCodex) {
+                    showGuideAtEnd = true;
+                }
+            }
+            else {
+                if (!hasClaude) {
+                    justInstalledClaude = installProviderPackage(CLAUDE_PKG);
+                    hasClaude = checkClaude();
+                    installedClaudeThisRun = true;
+                    if (hasClaude && process.stdin.isTTY) {
+                        console.log("\nSwitching to Claude to sign in. Exit when done.\n");
+                        spawnSync("claude", [], { stdio: "inherit", cwd: projectRoot, shell: true });
+                    }
+                }
+                else if (!hasCodex) {
+                    installProviderPackage(CODEX_PKG);
+                    hasCodex = checkCodex();
+                    installedCodexThisRun = true;
+                    if (hasCodex && process.stdin.isTTY) {
+                        console.log("\nSwitching to Codex to sign in. Exit with Ctrl+C when done.\n");
+                        spawnSync("codex", [], { stdio: "inherit", cwd: projectRoot, shell: true });
+                    }
+                }
+                if (hasClaude && hasCodex) {
+                    showCompleteBox(hasClaude, hasCodex, "Both providers are ready.");
+                }
+            }
+        }
+        if (hasClaude && !finishedWithCodexOnly) {
+            try {
+                runCommand("claude", ["/init"], projectRoot);
+            }
+            catch (err) {
+                console.warn("Warning: claude /init failed:", err.message);
+                const claudeMdPath = resolve(projectRoot, "CLAUDE.md");
+                if (!(await fs.pathExists(claudeMdPath))) {
+                    await fs.writeFile(claudeMdPath, DEFAULT_CLAUDE_MD, "utf-8");
+                    console.log("  Created CLAUDE.md");
+                }
+                console.log("  Claude /init failed (sign in may be required). Run 'claude' to sign in, then run 'claude /init' in this project.");
+            }
+        }
+        if (hasCodex) {
+            const agentsPath = resolve(projectRoot, "AGENTS.md");
+            if (!(await fs.pathExists(agentsPath))) {
+                await fs.writeFile(agentsPath, DEFAULT_AGENTS_MD, "utf-8");
+                console.log("  Created AGENTS.md");
+            }
+        }
+        await installTemplates(projectRoot);
+        const plansDir = getPlansDir(projectRoot);
+        await fs.ensureDir(plansDir);
+        const configPath = resolve(projectRoot, "planforge.json");
+        const configExists = await fs.pathExists(configPath);
+        let createdConfig = false;
+        let updatedConfig = false;
+        if (!configExists) {
+            const preset = getPresetForProviders(hasClaude, hasCodex);
+            await fs.writeJson(configPath, preset, { spaces: 2 });
+            createdConfig = true;
+        }
+        else {
+            const current = (await fs.readJson(configPath));
+            const suggested = getPresetForProviders(hasClaude, hasCodex);
+            if (!configEqual(current, suggested) && process.stdin.isTTY) {
+                console.log("");
+                console.log("  planforge.json already exists. Current config differs from suggested for your installed providers.");
+                console.log("");
+                console.log("  Current:   planner     " + formatRole(current, "planner"));
+                console.log("             implementer " + formatRole(current, "implementer"));
+                console.log("");
+                console.log("  Suggested: planner     " + formatRole(suggested, "planner"));
+                console.log("             implementer " + formatRole(suggested, "implementer"));
+                console.log("");
+                const raw = await ask("Update planforge.json to suggested? (1) Yes (2) No, keep current", "2");
+                const n = raw === "" ? 2 : parseInt(raw, 10);
+                if (n === 1) {
+                    await fs.writeJson(configPath, suggested, { spaces: 2 });
+                    updatedConfig = true;
+                }
+            }
+        }
+        console.log("");
+        if (showGuideAtEnd) {
+            console.log("  Congratulations! PlanForge is ready.");
+            console.log("");
+            console.log("  Example: Design a simple tetris game.");
+            console.log("  In Cursor, use /p for planning and /i for implementation. Try it out!");
+            console.log("");
+        }
+        console.log("  Created .cursor/plans");
+        if (createdConfig) {
+            console.log("  Created planforge.json");
+        }
+        else if (updatedConfig) {
+            console.log("  Updated planforge.json to suggested config.");
+        }
+        console.log("");
+        console.log("PlanForge init complete.");
+    }
+    catch (err) {
+        console.error("PlanForge init failed:", err.message);
+        process.exit(1);
+    }
+}

package/dist/commands/install.js

@@ -0,0 +1,18 @@
+/**
+ * planforge install - install Cursor slash commands and templates
+ */
+import { getProjectRoot } from "../utils/paths.js";
+import { installTemplates } from "../templates/install.js";
+export async function runInstall(args) {
+    const force = args.includes("--force");
+    const cwd = process.cwd();
+    const projectRoot = getProjectRoot(cwd);
+    try {
+        await installTemplates(projectRoot, { force });
+        console.log("PlanForge templates installed to .cursor/skills and .cursor/rules.");
+    }
+    catch (err) {
+        console.error("Install failed:", err.message);
+        process.exit(1);
+    }
+}