javi-forge 1.6.0 → 1.7.0

package/dist/commands/doctor.d.ts

@@ -1,5 +1,5 @@
-import type { DoctorResult } from '../types/index.js';
-export type CheckStatus = 'ok' | 'fail' | 'skip';
+import type { DoctorResult } from "../types/index.js";
+export type CheckStatus = "ok" | "fail" | "skip";
 /**
  * Run comprehensive health checks for the project and framework.
  */

package/dist/commands/doctor.js

@@ -1,15 +1,14 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { detectStack } from '../lib/common.js';
-import { listInstalledPlugins } from '../lib/plugin.js';
-import { FORGE_ROOT, TEMPLATES_DIR, MODULES_DIR, PLUGINS_DIR } from '../constants.js';
-const execFileAsync = promisify(execFile);
+import path from "node:path";
+import fs from "fs-extra";
+import { FORGE_ROOT, MODULES_DIR, PLUGINS_DIR, TEMPLATES_DIR, } from "../constants.js";
+import { detectStack } from "../lib/common.js";
+import { refreshContextDir } from "../lib/context.js";
+import { execFileAsync } from "../lib/exec.js";
+import { listInstalledPlugins } from "../lib/plugin.js";
 /** Resolve a binary name to its full path, returns null if not found */
 async function which(bin) {
     try {
-        const { stdout } = await execFileAsync('which', [bin]);
+        const { stdout } = await execFileAsync("which", [bin]);
         return stdout.trim() || null;
     }
     catch {
@@ -18,11 +17,11 @@ async function which(bin) {
 }
 /** Read the forge manifest from a project directory */
 async function readManifest(projectDir) {
-    const manifestPath = path.join(projectDir, '.javi-forge', 'manifest.json');
-    if (!await fs.pathExists(manifestPath))
+    const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
+    if (!(await fs.pathExists(manifestPath)))
         return null;
     try {
-        return await fs.readJson(manifestPath);
+        return (await fs.readJson(manifestPath));
     }
     catch {
         return null;
@@ -30,10 +29,10 @@ async function readManifest(projectDir) {
 }
 /** Count entries in a directory */
 async function countDir(dir) {
-    if (!await fs.pathExists(dir))
+    if (!(await fs.pathExists(dir)))
         return 0;
     const entries = await fs.readdir(dir);
-    return entries.filter(e => !e.startsWith('.')).length;
+    return entries.filter((e) => !e.startsWith(".")).length;
 }
 /**
  * Run comprehensive health checks for the project and framework.
@@ -44,114 +43,130 @@ export async function runDoctor(projectDir) {
     // ── 1. System Tools ────────────────────────────────────────────────────────
     const toolChecks = [];
     const tools = [
-        { name: 'git', label: 'Git' },
-        { name: 'docker', label: 'Docker' },
-        { name: 'semgrep', label: 'Semgrep' },
-        { name: 'node', label: 'Node.js' },
-        { name: 'pnpm', label: 'pnpm' },
+        { name: "git", label: "Git" },
+        { name: "docker", label: "Docker" },
+        { name: "semgrep", label: "Semgrep" },
+        { name: "node", label: "Node.js" },
+        { name: "pnpm", label: "pnpm" },
     ];
     for (const tool of tools) {
         const bin = await which(tool.name);
         if (bin) {
             // Try to get version
-            let version = '';
+            let version = "";
             try {
-                const { stdout } = await execFileAsync(tool.name, ['--version']);
-                version = stdout.trim().split('\n')[0] ?? '';
+                const { stdout } = await execFileAsync(tool.name, ["--version"]);
+                version = stdout.trim().split("\n")[0] ?? "";
+            }
+            catch {
+                /* ignore */
             }
-            catch { /* ignore */ }
             toolChecks.push({
                 label: tool.label,
-                status: 'ok',
+                status: "ok",
                 detail: version ? `${version}` : `found at ${bin}`,
             });
         }
         else {
             toolChecks.push({
                 label: tool.label,
-                status: tool.name === 'docker' || tool.name === 'semgrep' ? 'skip' : 'fail',
-                detail: 'not found in PATH',
+                status: tool.name === "docker" || tool.name === "semgrep" ? "skip" : "fail",
+                detail: "not found in PATH",
             });
         }
     }
-    sections.push({ title: 'System Tools', checks: toolChecks });
+    sections.push({ title: "System Tools", checks: toolChecks });
     // ── 2. Framework Structure ─────────────────────────────────────────────────
     const structureChecks = [];
     const expectedDirs = [
-        { path: TEMPLATES_DIR, label: 'templates/' },
-        { path: MODULES_DIR, label: 'modules/' },
-        { path: path.join(FORGE_ROOT, 'workflows'), label: 'workflows/' },
-        { path: path.join(FORGE_ROOT, 'ci-local'), label: 'ci-local/' },
+        { path: TEMPLATES_DIR, label: "templates/" },
+        { path: MODULES_DIR, label: "modules/" },
+        { path: path.join(FORGE_ROOT, "workflows"), label: "workflows/" },
+        { path: path.join(FORGE_ROOT, "ci-local"), label: "ci-local/" },
     ];
     for (const dir of expectedDirs) {
         if (await fs.pathExists(dir.path)) {
             const count = await countDir(dir.path);
-            structureChecks.push({ label: dir.label, status: 'ok', detail: `${count} entries` });
+            structureChecks.push({
+                label: dir.label,
+                status: "ok",
+                detail: `${count} entries`,
+            });
         }
         else {
-            structureChecks.push({ label: dir.label, status: 'fail', detail: 'missing' });
+            structureChecks.push({
+                label: dir.label,
+                status: "fail",
+                detail: "missing",
+            });
         }
     }
-    sections.push({ title: 'Framework Structure', checks: structureChecks });
+    sections.push({ title: "Framework Structure", checks: structureChecks });
     // ── 3. Stack Detection ─────────────────────────────────────────────────────
     const stackChecks = [];
     const detection = await detectStack(cwd);
     if (detection) {
         stackChecks.push({
-            label: 'Detected stack',
-            status: 'ok',
-            detail: `${detection.stackType} (${detection.buildTool})${detection.javaVersion ? ` Java ${detection.javaVersion}` : ''}`,
+            label: "Detected stack",
+            status: "ok",
+            detail: `${detection.stackType} (${detection.buildTool})${detection.javaVersion ? ` Java ${detection.javaVersion}` : ""}`,
         });
     }
     else {
         stackChecks.push({
-            label: 'Detected stack',
-            status: 'skip',
-            detail: 'no recognizable project files in current directory',
+            label: "Detected stack",
+            status: "skip",
+            detail: "no recognizable project files in current directory",
         });
     }
-    sections.push({ title: 'Stack Detection', checks: stackChecks });
+    sections.push({ title: "Stack Detection", checks: stackChecks });
     // ── 4. Project Manifest ────────────────────────────────────────────────────
     const manifestChecks = [];
     const manifest = await readManifest(cwd);
     if (manifest) {
         manifestChecks.push({
-            label: 'Forge manifest',
-            status: 'ok',
+            label: "Forge manifest",
+            status: "ok",
             detail: `project: ${manifest.projectName}, stack: ${manifest.stack}`,
         });
         manifestChecks.push({
-            label: 'Created',
-            status: 'ok',
-            detail: manifest.createdAt.split('T')[0],
+            label: "Created",
+            status: "ok",
+            detail: manifest.createdAt.split("T")[0],
         });
         manifestChecks.push({
-            label: 'Modules',
-            status: manifest.modules.length > 0 ? 'ok' : 'skip',
-            detail: manifest.modules.length > 0 ? manifest.modules.join(', ') : 'none installed',
+            label: "Modules",
+            status: manifest.modules.length > 0 ? "ok" : "skip",
+            detail: manifest.modules.length > 0
+                ? manifest.modules.join(", ")
+                : "none installed",
         });
     }
     else {
         manifestChecks.push({
-            label: 'Forge manifest',
-            status: 'skip',
-            detail: 'not a forge-managed project (run javi-forge init)',
+            label: "Forge manifest",
+            status: "skip",
+            detail: "not a forge-managed project (run javi-forge init)",
         });
     }
-    sections.push({ title: 'Project Manifest', checks: manifestChecks });
+    sections.push({ title: "Project Manifest", checks: manifestChecks });
     // ── 5. Installed Modules ───────────────────────────────────────────────────
     const moduleChecks = [];
-    const moduleNames = ['engram', 'obsidian-brain', 'memory-simple', 'ghagga'];
+    const moduleNames = ["engram", "obsidian-brain", "memory-simple", "ghagga"];
     for (const mod of moduleNames) {
-        const modPath = path.join(cwd, '.javi-forge', 'modules', mod);
+        const modPath = path.join(cwd, ".javi-forge", "modules", mod);
         if (await fs.pathExists(modPath)) {
-            moduleChecks.push({ label: mod, status: 'ok', detail: 'installed' });
+            moduleChecks.push({ label: mod, status: "ok", detail: "installed" });
         }
         else {
-            moduleChecks.push({ label: mod, status: 'skip', detail: 'not installed' });
+            moduleChecks.push({
+                label: mod,
+                status: "skip",
+                detail: "not installed",
+            });
         }
     }
-    sections.push({ title: 'Installed Modules', checks: moduleChecks });
+    sections.push({ title: "Installed Modules", checks: moduleChecks });
     // ── 6. Plugins ─────────────────────────────────────────────────────────────
     const pluginChecks = [];
     const pluginsDirExists = await fs.pathExists(PLUGINS_DIR);
@@ -161,19 +176,54 @@ export async function runDoctor(projectDir) {
             for (const plugin of plugins) {
                 pluginChecks.push({
                     label: plugin.name,
-                    status: 'ok',
+                    status: "ok",
                     detail: `v${plugin.version} from ${plugin.source}`,
                 });
             }
         }
         else {
-            pluginChecks.push({ label: 'Plugins', status: 'skip', detail: 'none installed' });
+            pluginChecks.push({
+                label: "Plugins",
+                status: "skip",
+                detail: "none installed",
+            });
         }
     }
     else {
-        pluginChecks.push({ label: 'Plugins directory', status: 'skip', detail: 'not created yet' });
+        pluginChecks.push({
+            label: "Plugins directory",
+            status: "skip",
+            detail: "not created yet",
+        });
+    }
+    sections.push({ title: "Plugins", checks: pluginChecks });
+    // ── 7. Context Directory Refresh ───────────────────────────────────────────
+    const contextChecks = [];
+    try {
+        const result = await refreshContextDir(cwd);
+        if (result) {
+            contextChecks.push({
+                label: ".context/ refresh",
+                status: "ok",
+                detail: "INDEX.md + summary.md updated",
+            });
+        }
+        else {
+            contextChecks.push({
+                label: ".context/ refresh",
+                status: "skip",
+                detail: "no .context/ or no manifest found",
+            });
+        }
+    }
+    catch (e) {
+        contextChecks.push({
+            label: ".context/ refresh",
+            status: "fail",
+            detail: `refresh failed: ${String(e)}`,
+        });
     }
-    sections.push({ title: 'Plugins', checks: pluginChecks });
+    sections.push({ title: "Context Directory", checks: contextChecks });
     return { sections };
 }
 //# sourceMappingURL=doctor.js.map

package/dist/commands/init/report.d.ts

@@ -0,0 +1,13 @@
+import type { InitStep } from "../../types/index.js";
+import type { StepCallback } from "./types.js";
+/**
+ * Emit a step progress event via the callback.
+ *
+ * Centralized helper extracted during the init.ts split. Functionally
+ * identical to the original inline report function, with an explicit
+ * `void` return type added for type clarity. Behavior MUST stay
+ * compatible so tests asserting on emitted steps[] (and the ordering
+ * contract test) keep passing through the PR 1-6 extraction.
+ */
+export declare function report(onStep: StepCallback, id: string, label: string, status: InitStep["status"], detail?: string): void;
+//# sourceMappingURL=report.d.ts.map

package/dist/commands/init/report.js

@@ -0,0 +1,13 @@
+/**
+ * Emit a step progress event via the callback.
+ *
+ * Centralized helper extracted during the init.ts split. Functionally
+ * identical to the original inline report function, with an explicit
+ * `void` return type added for type clarity. Behavior MUST stay
+ * compatible so tests asserting on emitted steps[] (and the ordering
+ * contract test) keep passing through the PR 1-6 extraction.
+ */
+export function report(onStep, id, label, status, detail) {
+    onStep({ id, label, status, detail });
+}
+//# sourceMappingURL=report.js.map

package/dist/commands/init/steps/agent-skills.d.ts

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 17: Generate Agent Skills manifest (skills.json).
+ *
+ * - In dry-run mode, reports what would be created without touching disk.
+ * - Otherwise writes <projectDir>/<AGENT_SKILLS_MANIFEST_FILE> with an empty
+ *   skills array unless the file already exists (idempotent).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export declare const stepAgentSkills: StepFn;
+//# sourceMappingURL=agent-skills.d.ts.map

package/dist/commands/init/steps/agent-skills.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { AGENT_SKILLS_MANIFEST_FILE } from "../../../constants.js";
+import { report } from "../report.js";
+/**
+ * Step 17: Generate Agent Skills manifest (skills.json).
+ *
+ * - In dry-run mode, reports what would be created without touching disk.
+ * - Otherwise writes <projectDir>/<AGENT_SKILLS_MANIFEST_FILE> with an empty
+ *   skills array unless the file already exists (idempotent).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export const stepAgentSkills = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { projectName } = options;
+    const stepId = "agent-skills";
+    report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "running");
+    try {
+        if (!dryRun) {
+            const skillsManifest = {
+                name: projectName,
+                version: "0.1.0",
+                description: `Agent Skills manifest for ${projectName}`,
+                skills: [],
+            };
+            const skillsJsonPath = path.join(projectDir, AGENT_SKILLS_MANIFEST_FILE);
+            if (!(await fs.pathExists(skillsJsonPath))) {
+                await fs.writeJson(skillsJsonPath, skillsManifest, { spaces: 2 });
+                report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", AGENT_SKILLS_MANIFEST_FILE);
+            }
+            else {
+                report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", "already exists");
+            }
+        }
+        else {
+            report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", `dry-run: would generate ${AGENT_SKILLS_MANIFEST_FILE}`);
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "error", String(e));
+    }
+};
+//# sourceMappingURL=agent-skills.js.map

package/dist/commands/init/steps/ai-sync.d.ts

@@ -0,0 +1,15 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 7: AI config sync (delegated to javi-ai).
+ *
+ * - When aiSync is false, reports "skipped".
+ * - When dryRun, reports a done message without invoking javi-ai.
+ * - Otherwise shells out to `npx javi-ai sync --project-dir <projectDir> --target all`.
+ * - Detects soft failures via stderr (e.g. "Raw mode is not supported", "ERROR").
+ * - Hard failures (ENOENT, not found, ERR_MODULE_NOT_FOUND) report a helpful install hint.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export declare const stepAISync: StepFn;
+//# sourceMappingURL=ai-sync.d.ts.map

package/dist/commands/init/steps/ai-sync.js

@@ -0,0 +1,62 @@
+import { execFileAsync } from "../../../lib/exec.js";
+import { report } from "../report.js";
+/**
+ * Step 7: AI config sync (delegated to javi-ai).
+ *
+ * - When aiSync is false, reports "skipped".
+ * - When dryRun, reports a done message without invoking javi-ai.
+ * - Otherwise shells out to `npx javi-ai sync --project-dir <projectDir> --target all`.
+ * - Detects soft failures via stderr (e.g. "Raw mode is not supported", "ERROR").
+ * - Hard failures (ENOENT, not found, ERR_MODULE_NOT_FOUND) report a helpful install hint.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export const stepAISync = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { aiSync } = options;
+    const stepId = "ai-sync";
+    report(onStep, stepId, "Sync AI config via javi-ai", "running");
+    try {
+        if (aiSync) {
+            if (!dryRun) {
+                try {
+                    const { stderr } = await execFileAsync("npx", ["javi-ai", "sync", "--project-dir", projectDir, "--target", "all"], {
+                        cwd: projectDir,
+                        timeout: 120_000,
+                    });
+                    // javi-ai may exit 0 but crash (e.g. Ink raw mode error) — detect via stderr
+                    if (stderr &&
+                        (stderr.includes("Raw mode is not supported") ||
+                            stderr.includes("ERROR"))) {
+                        report(onStep, stepId, "Sync AI config via javi-ai", "error", "javi-ai crashed. Run manually: npx javi-ai sync --project-dir . --target all");
+                    }
+                    else {
+                        report(onStep, stepId, "Sync AI config via javi-ai", "done", "javi-ai sync --target all");
+                    }
+                }
+                catch (syncErr) {
+                    const msg = syncErr instanceof Error ? syncErr.message : String(syncErr);
+                    if (msg.includes("ENOENT") ||
+                        msg.includes("not found") ||
+                        msg.includes("ERR_MODULE_NOT_FOUND")) {
+                        report(onStep, stepId, "Sync AI config via javi-ai", "error", "javi-ai not found. Install with: npm install -g javi-ai (or run npx javi-ai sync manually)");
+                    }
+                    else {
+                        report(onStep, stepId, "Sync AI config via javi-ai", "error", msg);
+                    }
+                }
+            }
+            else {
+                report(onStep, stepId, "Sync AI config via javi-ai", "done", "dry-run: would run javi-ai sync --target all");
+            }
+        }
+        else {
+            report(onStep, stepId, "Sync AI config via javi-ai", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Sync AI config via javi-ai", "error", String(e));
+    }
+};
+//# sourceMappingURL=ai-sync.js.map

package/dist/commands/init/steps/ci.d.ts

@@ -0,0 +1,24 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 3: Copy CI template.
+ *
+ * - Generates the CI workflow for the detected stack + provider.
+ * - Writes to getCIDestination(ciProvider), backing up any existing file.
+ * - Skips with "no template for <stack>" when generateCIWorkflow returns empty.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export declare const stepCITemplate: StepFn;
+/**
+ * Step 5: Generate dependabot.yml.
+ *
+ * - Only runs when ciProvider === "github".
+ * - Writes .github/dependabot.yml with backup of any existing file.
+ * - Otherwise reports skipped with "not needed for <ciProvider>".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export declare const stepDependabot: StepFn;
+//# sourceMappingURL=ci.d.ts.map

package/dist/commands/init/steps/ci.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { backupIfExists, ensureDirExists } from "../../../lib/common.js";
+import { generateCIWorkflow, generateDependabotYml, getCIDestination, } from "../../../lib/template.js";
+import { report } from "../report.js";
+/**
+ * Step 3: Copy CI template.
+ *
+ * - Generates the CI workflow for the detected stack + provider.
+ * - Writes to getCIDestination(ciProvider), backing up any existing file.
+ * - Skips with "no template for <stack>" when generateCIWorkflow returns empty.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export const stepCITemplate = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { stack, ciProvider } = options;
+    const stepId = "ci-template";
+    report(onStep, stepId, `Copy ${ciProvider} CI workflow`, "running");
+    try {
+        const ciContent = await generateCIWorkflow(stack, ciProvider);
+        if (ciContent) {
+            const dest = path.join(projectDir, getCIDestination(ciProvider));
+            if (!dryRun) {
+                await backupIfExists(dest);
+                await ensureDirExists(path.dirname(dest));
+                await fs.writeFile(dest, ciContent, "utf-8");
+            }
+            report(onStep, stepId, `Copy ${ciProvider} CI workflow`, "done", getCIDestination(ciProvider));
+        }
+        else {
+            report(onStep, stepId, `Copy ${ciProvider} CI workflow`, "skipped", `no template for ${stack}`);
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, `Copy ${ciProvider} CI workflow`, "error", String(e));
+    }
+};
+/**
+ * Step 5: Generate dependabot.yml.
+ *
+ * - Only runs when ciProvider === "github".
+ * - Writes .github/dependabot.yml with backup of any existing file.
+ * - Otherwise reports skipped with "not needed for <ciProvider>".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export const stepDependabot = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { stack, ciProvider } = options;
+    const stepId = "dependabot";
+    report(onStep, stepId, "Generate dependabot.yml", "running");
+    try {
+        if (ciProvider === "github") {
+            const content = await generateDependabotYml([stack], true);
+            const dest = path.join(projectDir, ".github", "dependabot.yml");
+            if (!dryRun) {
+                await backupIfExists(dest);
+                await ensureDirExists(path.dirname(dest));
+                await fs.writeFile(dest, content, "utf-8");
+            }
+            report(onStep, stepId, "Generate dependabot.yml", "done");
+        }
+        else {
+            report(onStep, stepId, "Generate dependabot.yml", "skipped", `not needed for ${ciProvider}`);
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate dependabot.yml", "error", String(e));
+    }
+};
+//# sourceMappingURL=ci.js.map

package/dist/commands/init/steps/claude-md.d.ts

@@ -0,0 +1,14 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 12: Generate CLAUDE.md (smart: project-aware).
+ *
+ * - When claudeMd is false, reports "skipped".
+ * - If CLAUDE.md already exists at the project root, reports "done" with "already exists".
+ * - Otherwise detects the project stack and writes a smart CLAUDE.md;
+ *   the detail mentions the number of recommended skills detected.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export declare const stepClaudeMd: StepFn;
+//# sourceMappingURL=claude-md.d.ts.map

package/dist/commands/init/steps/claude-md.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { generateSmartClaudeMd } from "../../../lib/claudemd.js";
+import { detectProjectStack } from "../../../lib/stack-detector.js";
+import { report } from "../report.js";
+/**
+ * Step 12: Generate CLAUDE.md (smart: project-aware).
+ *
+ * - When claudeMd is false, reports "skipped".
+ * - If CLAUDE.md already exists at the project root, reports "done" with "already exists".
+ * - Otherwise detects the project stack and writes a smart CLAUDE.md;
+ *   the detail mentions the number of recommended skills detected.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export const stepClaudeMd = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { claudeMd } = options;
+    const stepId = "claude-md";
+    report(onStep, stepId, "Generate CLAUDE.md", "running");
+    try {
+        if (claudeMd) {
+            const claudeMdPath = path.join(projectDir, "CLAUDE.md");
+            if (await fs.pathExists(claudeMdPath)) {
+                report(onStep, stepId, "Generate CLAUDE.md", "done", "already exists");
+            }
+            else {
+                if (!dryRun) {
+                    // Detect project stack for smart CLAUDE.md generation
+                    const detection = await detectProjectStack(projectDir).catch(() => null);
+                    const content = generateSmartClaudeMd(options, detection);
+                    await fs.writeFile(claudeMdPath, content, "utf-8");
+                    // detection itself can be null from .catch(() => null) above;
+                    // recommendedSkills is always an array if detection succeeds.
+                    const skillCount = detection?.recommendedSkills.length ?? 0;
+                    report(onStep, stepId, "Generate CLAUDE.md", "done", skillCount > 0
+                        ? `CLAUDE.md (${skillCount} skills detected)`
+                        : "CLAUDE.md");
+                }
+                else {
+                    report(onStep, stepId, "Generate CLAUDE.md", "done", "dry-run: would generate CLAUDE.md");
+                }
+            }
+        }
+        else {
+            report(onStep, stepId, "Generate CLAUDE.md", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate CLAUDE.md", "error", String(e));
+    }
+};
+//# sourceMappingURL=claude-md.js.map

package/dist/commands/init/steps/code-graph.d.ts

@@ -0,0 +1,16 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 15: Scaffold RepoForge code graph.
+ *
+ * - When options.codeGraph is false, reports "skipped".
+ * - Otherwise:
+ *   1. Copies .repoforge.yaml config (skip if exists).
+ *   2. Ensures .repoforge/ output dir exists.
+ *   3. Copies the graph generation CI workflow when ciProvider === "github".
+ *   4. Copies the MCP config snippet with __PROJECT_NAME__ interpolation.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ */
+export declare const stepCodeGraph: StepFn;
+//# sourceMappingURL=code-graph.d.ts.map