javi-forge 1.6.1 → 1.7.0

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

@@ -0,0 +1,81 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { CI_LOCAL_DIR } from "../../../constants.js";
+import { execFileAsync } from "../../../lib/exec.js";
+import { report } from "../report.js";
+/**
+ * Step 1: Initialize git repository.
+ *
+ * - If .git is missing, runs `git init` in the project dir.
+ * - If .git already exists, reports "done" with detail "already exists".
+ * - In dry-run, skips the actual `git init` call but still reports.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 1 of 6).
+ */
+export const stepGitInit = async (ctx) => {
+    const { projectDir, dryRun, onStep } = ctx;
+    const stepId = "git-init";
+    report(onStep, stepId, "Initialize git repository", "running");
+    try {
+        const gitDir = path.join(projectDir, ".git");
+        if (!(await fs.pathExists(gitDir))) {
+            if (!dryRun) {
+                await execFileAsync("git", ["init"], { cwd: projectDir });
+            }
+            report(onStep, stepId, "Initialize git repository", "done", "initialized");
+        }
+        else {
+            report(onStep, stepId, "Initialize git repository", "done", "already exists");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Initialize git repository", "error", String(e));
+    }
+};
+/**
+ * Step 2: Configure git hooks path.
+ *
+ * - Copies templates/ci-local/ → <project>/ci-local/ (no overwrite).
+ * - chmod 0755 on hook files.
+ * - Sets git config core.hooksPath to ci-local/hooks.
+ * - Skips entirely when CI_LOCAL_DIR template is missing.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 1 of 6).
+ */
+export const stepGitHooks = async (ctx) => {
+    const { projectDir, dryRun, onStep } = ctx;
+    const stepId = "git-hooks";
+    report(onStep, stepId, "Configure git hooks path", "running");
+    try {
+        const ciLocalSrc = CI_LOCAL_DIR;
+        const ciLocalDest = path.join(projectDir, "ci-local");
+        if (await fs.pathExists(ciLocalSrc)) {
+            if (!dryRun) {
+                await fs.copy(ciLocalSrc, ciLocalDest, {
+                    overwrite: false,
+                    errorOnExist: false,
+                });
+                // Set core.hooksPath to ci-local/hooks
+                const hooksDir = path.join(ciLocalDest, "hooks");
+                if (await fs.pathExists(hooksDir)) {
+                    // Ensure hooks are executable
+                    const hookFiles = await fs.readdir(hooksDir);
+                    for (const hook of hookFiles) {
+                        await fs.chmod(path.join(hooksDir, hook), 0o755);
+                    }
+                    await execFileAsync("git", ["config", "core.hooksPath", "ci-local/hooks"], { cwd: projectDir });
+                }
+            }
+            report(onStep, stepId, "Configure git hooks path", "done", "ci-local/hooks");
+        }
+        else {
+            report(onStep, stepId, "Configure git hooks path", "skipped", "no ci-local dir");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Configure git hooks path", "error", String(e));
+    }
+};
+//# sourceMappingURL=git.js.map

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

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 4: Generate .gitignore.
+ *
+ * - Copies <FORGE_ROOT>/.gitignore.template → <project>/.gitignore if absent.
+ * - If destination already exists, reports "done" with detail "already exists".
+ * - If template is missing, reports "skipped" with detail "no template".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export declare const stepGitignore: StepFn;
+//# sourceMappingURL=gitignore.d.ts.map

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

@@ -0,0 +1,39 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { FORGE_ROOT } from "../../../constants.js";
+import { report } from "../report.js";
+/**
+ * Step 4: Generate .gitignore.
+ *
+ * - Copies <FORGE_ROOT>/.gitignore.template → <project>/.gitignore if absent.
+ * - If destination already exists, reports "done" with detail "already exists".
+ * - If template is missing, reports "skipped" with detail "no template".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export const stepGitignore = async (ctx) => {
+    const { projectDir, dryRun, onStep } = ctx;
+    const stepId = "gitignore";
+    report(onStep, stepId, "Generate .gitignore", "running");
+    try {
+        const templatePath = path.join(FORGE_ROOT, ".gitignore.template");
+        const dest = path.join(projectDir, ".gitignore");
+        if ((await fs.pathExists(templatePath)) && !(await fs.pathExists(dest))) {
+            if (!dryRun) {
+                await fs.copy(templatePath, dest);
+            }
+            report(onStep, stepId, "Generate .gitignore", "done", "from template");
+        }
+        else if (await fs.pathExists(dest)) {
+            report(onStep, stepId, "Generate .gitignore", "done", "already exists");
+        }
+        else {
+            report(onStep, stepId, "Generate .gitignore", "skipped", "no template");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate .gitignore", "error", String(e));
+    }
+};
+//# sourceMappingURL=gitignore.js.map

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

@@ -0,0 +1,14 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 16: Scaffold local AI dev stack.
+ *
+ * - When options.localAi is false, reports "skipped".
+ * - When LOCAL_AI_TEMPLATE_DIR is missing, reports "error".
+ * - Otherwise copies docker-compose.yml and .env.example -> .env.local-ai
+ *   (both skip if the destination already exists).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ */
+export declare const stepLocalAi: StepFn;
+//# sourceMappingURL=local-ai.d.ts.map

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

@@ -0,0 +1,53 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { LOCAL_AI_TEMPLATE_DIR } from "../../../constants.js";
+import { report } from "../report.js";
+/**
+ * Step 16: Scaffold local AI dev stack.
+ *
+ * - When options.localAi is false, reports "skipped".
+ * - When LOCAL_AI_TEMPLATE_DIR is missing, reports "error".
+ * - Otherwise copies docker-compose.yml and .env.example -> .env.local-ai
+ *   (both skip if the destination already exists).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ */
+export const stepLocalAi = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const stepId = "local-ai";
+    report(onStep, stepId, "Scaffold local AI dev stack", "running");
+    try {
+        if (options.localAi) {
+            if (await fs.pathExists(LOCAL_AI_TEMPLATE_DIR)) {
+                const composeDest = path.join(projectDir, "docker-compose.yml");
+                const envDest = path.join(projectDir, ".env.local-ai");
+                if (!dryRun) {
+                    // Copy docker-compose.yml (skip if exists)
+                    if (!(await fs.pathExists(composeDest))) {
+                        await fs.copy(path.join(LOCAL_AI_TEMPLATE_DIR, "docker-compose.yml"), composeDest);
+                    }
+                    // Copy .env.example as .env.local-ai
+                    const envSrc = path.join(LOCAL_AI_TEMPLATE_DIR, ".env.example");
+                    if ((await fs.pathExists(envSrc)) &&
+                        !(await fs.pathExists(envDest))) {
+                        await fs.copy(envSrc, envDest);
+                    }
+                }
+                report(onStep, stepId, "Scaffold local AI dev stack", "done", dryRun
+                    ? "dry-run: would create docker-compose.yml + .env.local-ai"
+                    : "docker-compose.yml + .env.local-ai");
+            }
+            else {
+                report(onStep, stepId, "Scaffold local AI dev stack", "error", "local-ai template not found");
+            }
+        }
+        else {
+            report(onStep, stepId, "Scaffold local AI dev stack", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Scaffold local AI dev stack", "error", String(e));
+    }
+};
+//# sourceMappingURL=local-ai.js.map

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

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 18: Write the forge manifest under .javi-forge/manifest.json.
+ *
+ * - In dry-run mode, reports what would be written without touching disk.
+ * - Otherwise materialises .javi-forge/, computes the modules array from
+ *   selected options, and writes manifest.json (overwriting any existing).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export declare const stepManifest: StepFn;
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1,58 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.js";
+/**
+ * Step 18: Write the forge manifest under .javi-forge/manifest.json.
+ *
+ * - In dry-run mode, reports what would be written without touching disk.
+ * - Otherwise materialises .javi-forge/, computes the modules array from
+ *   selected options, and writes manifest.json (overwriting any existing).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export const stepManifest = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { stack, ciProvider, memory, aiSync, sdd, ghagga, contextDir, claudeMd, securityHooks, projectName, dockerDeploy, codeGraph, localAi, } = options;
+    const stepId = "manifest";
+    report(onStep, stepId, "Write forge manifest", "running");
+    try {
+        if (!dryRun) {
+            const manifestDir = path.join(projectDir, ".javi-forge");
+            await ensureDirExists(manifestDir);
+            const manifest = {
+                version: "0.1.0",
+                projectName,
+                stack,
+                ciProvider,
+                memory,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                modules: [
+                    ...(memory !== "none" ? [memory] : []),
+                    ...(ghagga ? ["ghagga"] : []),
+                    ...(sdd ? ["sdd"] : []),
+                    ...(aiSync ? ["ai-config"] : []),
+                    ...(contextDir ? ["context"] : []),
+                    ...(claudeMd ? ["claude-md"] : []),
+                    ...(dockerDeploy ? ["docker-deploy"] : []),
+                    ...(securityHooks ? ["security-hooks"] : []),
+                    ...(codeGraph ? ["code-graph"] : []),
+                    ...(localAi ? ["local-ai"] : []),
+                ],
+            };
+            await fs.writeJson(path.join(manifestDir, "manifest.json"), manifest, {
+                spaces: 2,
+            });
+            report(onStep, stepId, "Write forge manifest", "done", ".javi-forge/manifest.json");
+        }
+        else {
+            report(onStep, stepId, "Write forge manifest", "done", "dry-run: would write .javi-forge/manifest.json");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Write forge manifest", "error", String(e));
+    }
+};
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,15 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 6: Install memory module.
+ *
+ * - If memory === "none", reports "skipped".
+ * - Otherwise copies <MODULES_DIR>/<memory>/ → <project>/.javi-forge/modules/<memory>/.
+ * - For engram specifically, copies .mcp-config-snippet.json to project root
+ *   replacing __PROJECT_NAME__ placeholders.
+ * - If the module source dir is missing, reports "error" with "module not found".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export declare const stepMemory: StepFn;
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1,60 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { MODULES_DIR } from "../../../constants.js";
+import { ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.js";
+/**
+ * Step 6: Install memory module.
+ *
+ * - If memory === "none", reports "skipped".
+ * - Otherwise copies <MODULES_DIR>/<memory>/ → <project>/.javi-forge/modules/<memory>/.
+ * - For engram specifically, copies .mcp-config-snippet.json to project root
+ *   replacing __PROJECT_NAME__ placeholders.
+ * - If the module source dir is missing, reports "error" with "module not found".
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 2 of 6).
+ */
+export const stepMemory = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { memory, projectName } = options;
+    const stepId = "memory";
+    report(onStep, stepId, `Install memory module: ${memory}`, "running");
+    try {
+        if (memory !== "none") {
+            const moduleSrc = path.join(MODULES_DIR, memory);
+            if (await fs.pathExists(moduleSrc)) {
+                if (!dryRun) {
+                    // Copy module files to project
+                    const moduleDest = path.join(projectDir, ".javi-forge", "modules", memory);
+                    await ensureDirExists(moduleDest);
+                    await fs.copy(moduleSrc, moduleDest, {
+                        overwrite: false,
+                        errorOnExist: false,
+                    });
+                    // If engram, copy .mcp-config-snippet.json to project with placeholder replacement
+                    if (memory === "engram") {
+                        const snippetSrc = path.join(moduleSrc, ".mcp-config-snippet.json");
+                        if (await fs.pathExists(snippetSrc)) {
+                            const snippetDest = path.join(projectDir, ".mcp-config-snippet.json");
+                            let content = await fs.readFile(snippetSrc, "utf-8");
+                            content = content.replace(/__PROJECT_NAME__/g, projectName);
+                            await fs.writeFile(snippetDest, content, "utf-8");
+                        }
+                    }
+                }
+                report(onStep, stepId, `Install memory module: ${memory}`, "done");
+            }
+            else {
+                report(onStep, stepId, `Install memory module: ${memory}`, "error", "module not found");
+            }
+        }
+        else {
+            report(onStep, stepId, `Install memory module: ${memory}`, "skipped", "none selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, `Install memory module: ${memory}`, "error", String(e));
+    }
+};
+//# sourceMappingURL=memory.js.map

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

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 10: Configure mock-first mode.
+ *
+ * - When options.mock is false, reports "skipped".
+ * - Otherwise writes .env.example (and .env from it) with mock values, only if
+ *   the targets do not already exist.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export declare const stepMock: StepFn;
+//# sourceMappingURL=mock.d.ts.map

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

@@ -0,0 +1,64 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { report } from "../report.js";
+// Mock environment template — written verbatim to .env.example and .env
+// when mock-first mode is enabled. Preserved byte-for-byte from init.ts baseline.
+const envExample = `# Mock environment — no real API keys required
+# Copy to .env to use: cp .env.example .env
+
+# Database
+DATABASE_URL=postgresql://mock:mock@localhost:5432/mock_db
+
+# Auth
+JWT_SECRET=mock-jwt-secret-for-local-development
+SESSION_SECRET=mock-session-secret
+
+# External APIs (mock mode — no real calls)
+MOCK_MODE=true
+API_KEY=mock-api-key-not-real
+STRIPE_KEY=sk_test_mock_not_real
+SENDGRID_KEY=SG.mock_not_real
+
+# Feature flags
+ENABLE_ANALYTICS=false
+ENABLE_EMAILS=false
+ENABLE_WEBHOOKS=false
+`;
+/**
+ * Step 10: Configure mock-first mode.
+ *
+ * - When options.mock is false, reports "skipped".
+ * - Otherwise writes .env.example (and .env from it) with mock values, only if
+ *   the targets do not already exist.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export const stepMock = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const stepId = "mock";
+    if (options.mock) {
+        report(onStep, stepId, "Configure mock-first mode", "running");
+        try {
+            if (!dryRun) {
+                const envExamplePath = path.join(projectDir, ".env.example");
+                if (!(await fs.pathExists(envExamplePath))) {
+                    await fs.writeFile(envExamplePath, envExample, "utf-8");
+                }
+                // Create .env from example
+                const envPath = path.join(projectDir, ".env");
+                if (!(await fs.pathExists(envPath))) {
+                    await fs.writeFile(envPath, envExample, "utf-8");
+                }
+            }
+            report(onStep, stepId, "Configure mock-first mode", "done", ".env.example + .env with mock values");
+        }
+        catch (e) {
+            report(onStep, stepId, "Configure mock-first mode", "error", String(e));
+        }
+    }
+    else {
+        report(onStep, stepId, "Configure mock-first mode", "skipped", "not selected");
+    }
+};
+//# sourceMappingURL=mock.js.map

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

@@ -0,0 +1,12 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 8: Set up SDD (openspec/) scaffolding.
+ *
+ * - When sdd is false, reports "skipped".
+ * - Otherwise ensures openspec/ exists and writes a default README.md if absent.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export declare const stepSDD: StepFn;
+//# sourceMappingURL=sdd.d.ts.map

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

@@ -0,0 +1,40 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.js";
+/**
+ * Step 8: Set up SDD (openspec/) scaffolding.
+ *
+ * - When sdd is false, reports "skipped".
+ * - Otherwise ensures openspec/ exists and writes a default README.md if absent.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export const stepSDD = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { sdd, projectName } = options;
+    const stepId = "sdd";
+    report(onStep, stepId, "Set up SDD (openspec/)", "running");
+    try {
+        if (sdd) {
+            if (!dryRun) {
+                const openspecDir = path.join(projectDir, "openspec");
+                await ensureDirExists(openspecDir);
+                // Create a README if none exists
+                const readmePath = path.join(openspecDir, "README.md");
+                if (!(await fs.pathExists(readmePath))) {
+                    await fs.writeFile(readmePath, `# openspec/\n\nSpec-Driven Development artifacts for ${projectName}.\n\nSee: /sdd:new <name> to start a new change.\n`, "utf-8");
+                }
+            }
+            report(onStep, stepId, "Set up SDD (openspec/)", "done");
+        }
+        else {
+            report(onStep, stepId, "Set up SDD (openspec/)", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Set up SDD (openspec/)", "error", String(e));
+    }
+};
+//# sourceMappingURL=sdd.js.map

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

@@ -0,0 +1,28 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 14: Scaffold security hooks.
+ *
+ * - When options.securityHooks is false, reports "skipped".
+ * - When SECURITY_HOOKS_DIR templates are missing, reports "error".
+ * - Otherwise copies the 6-layer git security hooks into
+ *   ci-local/hooks/security/ (skipping existing files, chmod 0755) and copies
+ *   the kiteguard-style runtime settings to .claude/settings.json when absent.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ * Grouped with stepHookProfile for cohesion — both manage ci-local/hooks/.
+ */
+export declare const stepSecurityHooks: StepFn;
+/**
+ * Step 14b: Write hook reliability profile.
+ *
+ * - When options.securityHooks is false, reports "skipped".
+ * - Otherwise writes ci-local/hooks/profile.json with the resolved profile
+ *   (defaults to "standard" when hookProfile is undefined).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ * Grouped with stepSecurityHooks for cohesion — both manage ci-local/hooks/.
+ */
+export declare const stepHookProfile: StepFn;
+//# sourceMappingURL=security.d.ts.map

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

@@ -0,0 +1,103 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { SECURITY_HOOKS_DIR } from "../../../constants.js";
+import { ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.js";
+/**
+ * Step 14: Scaffold security hooks.
+ *
+ * - When options.securityHooks is false, reports "skipped".
+ * - When SECURITY_HOOKS_DIR templates are missing, reports "error".
+ * - Otherwise copies the 6-layer git security hooks into
+ *   ci-local/hooks/security/ (skipping existing files, chmod 0755) and copies
+ *   the kiteguard-style runtime settings to .claude/settings.json when absent.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ * Grouped with stepHookProfile for cohesion — both manage ci-local/hooks/.
+ */
+export const stepSecurityHooks = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { securityHooks } = options;
+    const stepId = "security-hooks";
+    report(onStep, stepId, "Scaffold security hooks", "running");
+    try {
+        if (securityHooks) {
+            if (await fs.pathExists(SECURITY_HOOKS_DIR)) {
+                if (!dryRun) {
+                    // Copy 6-layer git security hooks into ci-local/hooks/security/
+                    const secHooksDest = path.join(projectDir, "ci-local", "hooks", "security");
+                    await ensureDirExists(secHooksDest);
+                    const hookFiles = await fs.readdir(SECURITY_HOOKS_DIR);
+                    const gitHooks = hookFiles.filter((f) => !f.endsWith(".json"));
+                    for (const hook of gitHooks) {
+                        const src = path.join(SECURITY_HOOKS_DIR, hook);
+                        const dest = path.join(secHooksDest, hook);
+                        await fs.copy(src, dest, { overwrite: false });
+                        await fs.chmod(dest, 0o755);
+                    }
+                    // Copy runtime security settings (kiteguard-style) to .claude/
+                    const settingsSrc = path.join(SECURITY_HOOKS_DIR, "claude-settings-security.json");
+                    if (await fs.pathExists(settingsSrc)) {
+                        const claudeDir = path.join(projectDir, ".claude");
+                        await ensureDirExists(claudeDir);
+                        const settingsDest = path.join(claudeDir, "settings.json");
+                        if (!(await fs.pathExists(settingsDest))) {
+                            await fs.copy(settingsSrc, settingsDest);
+                        }
+                    }
+                }
+                report(onStep, stepId, "Scaffold security hooks", "done", dryRun
+                    ? "dry-run: would scaffold security hooks"
+                    : "6 git layers + runtime hooks");
+            }
+            else {
+                report(onStep, stepId, "Scaffold security hooks", "error", "security-hooks templates not found");
+            }
+        }
+        else {
+            report(onStep, stepId, "Scaffold security hooks", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Scaffold security hooks", "error", String(e));
+    }
+};
+/**
+ * Step 14b: Write hook reliability profile.
+ *
+ * - When options.securityHooks is false, reports "skipped".
+ * - Otherwise writes ci-local/hooks/profile.json with the resolved profile
+ *   (defaults to "standard" when hookProfile is undefined).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 5 of 6).
+ * Grouped with stepSecurityHooks for cohesion — both manage ci-local/hooks/.
+ */
+export const stepHookProfile = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { securityHooks, hookProfile } = options;
+    const stepId = "hook-profile";
+    report(onStep, stepId, "Write hook reliability profile", "running");
+    try {
+        if (securityHooks) {
+            if (!dryRun) {
+                const hooksDir = path.join(projectDir, "ci-local", "hooks");
+                await ensureDirExists(hooksDir);
+                const profilePath = path.join(hooksDir, "profile.json");
+                const resolvedProfile = hookProfile ?? "standard";
+                await fs.writeJson(profilePath, { profile: resolvedProfile }, { spaces: 2 });
+            }
+            report(onStep, stepId, "Write hook reliability profile", "done", dryRun
+                ? `dry-run: would write profile.json (${hookProfile ?? "standard"})`
+                : `ci-local/hooks/profile.json (${hookProfile ?? "standard"})`);
+        }
+        else {
+            report(onStep, stepId, "Write hook reliability profile", "skipped", "security hooks not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Write hook reliability profile", "error", String(e));
+    }
+};
+//# sourceMappingURL=security.js.map

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

@@ -0,0 +1,30 @@
+import type { InitOptions, InitStep } from "../../types/index.js";
+/**
+ * Callback invoked by each step to report progress.
+ * Steps emit at least 2 events: status:"running" followed by a terminal status
+ * ("done" | "skipped" | "error").
+ */
+export type StepCallback = (step: InitStep) => void;
+/**
+ * Context passed to every step. Built once by initProject and shared
+ * across all extracted step functions.
+ *
+ * Fields are intentionally minimal:
+ * - `options`: full InitOptions (steps can read any flag they need)
+ * - `projectDir`: convenience alias for options.projectDir
+ * - `dryRun`: convenience alias for options.dryRun
+ * - `onStep`: the progress callback (passed to report())
+ */
+export type StepContext = {
+    options: InitOptions;
+    projectDir: string;
+    dryRun: boolean;
+    onStep: StepCallback;
+};
+/**
+ * Step function signature. All step* functions follow this shape.
+ * Returns a promise that resolves when the step is complete
+ * (success, skipped, or recovered error — steps must NOT throw).
+ */
+export type StepFn = (ctx: StepContext) => Promise<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/init/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map