javi-forge 1.6.0 → 1.7.0

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

package/dist/commands/init.d.ts

@@ -1,9 +1,10 @@
-import type { InitOptions, InitStep } from '../types/index.js';
-type StepCallback = (step: InitStep) => void;
+import type { InitOptions } from "../types/index.js";
+import type { StepCallback } from "./init/types.js";
 /**
  * Main init orchestrator: bootstraps a project with CI, git hooks,
- * memory module, AI config sync, SDD, and ghagga.
+ * memory module, AI config sync, SDD, ghagga, and friends.
+ *
+ * Pure dispatch: every step lives in src/commands/init/steps/.
  */
 export declare function initProject(options: InitOptions, onStep: StepCallback): Promise<void>;
-export {};
 //# sourceMappingURL=init.d.ts.map