javi-forge 1.6.0 → 1.7.0

package/dist/commands/init/steps/code-graph.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { TEMPLATES_DIR } from "../../../constants.js";
+import { backupIfExists, ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.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 const stepCodeGraph = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { projectName, ciProvider } = options;
+    const stepId = "code-graph";
+    report(onStep, stepId, "Scaffold RepoForge code graph", "running");
+    try {
+        if (options.codeGraph) {
+            if (!dryRun) {
+                // 1. Copy .repoforge.yaml config
+                const repoforgeConfigSrc = path.join(TEMPLATES_DIR, "common", "repoforge", "repoforge.yaml");
+                const repoforgeConfigDest = path.join(projectDir, ".repoforge.yaml");
+                if (!(await fs.pathExists(repoforgeConfigDest))) {
+                    await fs.copy(repoforgeConfigSrc, repoforgeConfigDest);
+                }
+                // 2. Ensure .repoforge/ output dir exists
+                await ensureDirExists(path.join(projectDir, ".repoforge"));
+                // 3. Copy CI workflow for graph generation (GitHub only)
+                if (ciProvider === "github") {
+                    const graphWorkflowSrc = path.join(TEMPLATES_DIR, "github", "repoforge-graph.yml");
+                    if (await fs.pathExists(graphWorkflowSrc)) {
+                        const graphWorkflowDest = path.join(projectDir, ".github", "workflows", "repoforge-graph.yml");
+                        await ensureDirExists(path.dirname(graphWorkflowDest));
+                        await backupIfExists(graphWorkflowDest);
+                        await fs.copy(graphWorkflowSrc, graphWorkflowDest, {
+                            overwrite: false,
+                        });
+                    }
+                }
+                // 4. Copy MCP config snippet for repoforge code intelligence
+                const mcpSnippetSrc = path.join(TEMPLATES_DIR, "common", "repoforge", "mcp-repoforge-snippet.json");
+                if (await fs.pathExists(mcpSnippetSrc)) {
+                    const mcpSnippetDest = path.join(projectDir, ".repoforge", "mcp-config-snippet.json");
+                    let content = await fs.readFile(mcpSnippetSrc, "utf-8");
+                    content = content.replace(/__PROJECT_NAME__/g, projectName);
+                    await fs.writeFile(mcpSnippetDest, content, "utf-8");
+                }
+            }
+            report(onStep, stepId, "Scaffold RepoForge code graph", "done", dryRun
+                ? "dry-run: would scaffold .repoforge.yaml + CI + MCP"
+                : ".repoforge.yaml + CI + MCP snippet");
+        }
+        else {
+            report(onStep, stepId, "Scaffold RepoForge code graph", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Scaffold RepoForge code graph", "error", String(e));
+    }
+};
+//# sourceMappingURL=code-graph.js.map

package/dist/commands/init/steps/context-dir.d.ts

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 11: Generate .context/ directory.
+ *
+ * - When contextDir is false, reports "skipped".
+ * - If .context/ already exists, reports "done" with "already exists".
+ * - Otherwise generates INDEX.md + summary.md via generateContextDir().
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export declare const stepContextDir: StepFn;
+//# sourceMappingURL=context-dir.d.ts.map

package/dist/commands/init/steps/context-dir.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { ensureDirExists } from "../../../lib/common.js";
+import { generateContextDir } from "../../../lib/context.js";
+import { report } from "../report.js";
+/**
+ * Step 11: Generate .context/ directory.
+ *
+ * - When contextDir is false, reports "skipped".
+ * - If .context/ already exists, reports "done" with "already exists".
+ * - Otherwise generates INDEX.md + summary.md via generateContextDir().
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export const stepContextDir = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { contextDir } = options;
+    const stepId = "context-dir";
+    report(onStep, stepId, "Generate .context/ directory", "running");
+    try {
+        if (contextDir) {
+            const contextDirPath = path.join(projectDir, ".context");
+            if (await fs.pathExists(contextDirPath)) {
+                report(onStep, stepId, "Generate .context/ directory", "done", "already exists");
+            }
+            else {
+                if (!dryRun) {
+                    const { index, summary } = await generateContextDir(options);
+                    await ensureDirExists(contextDirPath);
+                    await fs.writeFile(path.join(contextDirPath, "INDEX.md"), index, "utf-8");
+                    await fs.writeFile(path.join(contextDirPath, "summary.md"), summary, "utf-8");
+                }
+                report(onStep, stepId, "Generate .context/ directory", "done", dryRun
+                    ? "dry-run: would generate .context/"
+                    : ".context/INDEX.md + summary.md");
+            }
+        }
+        else {
+            report(onStep, stepId, "Generate .context/ directory", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate .context/ directory", "error", String(e));
+    }
+};
+//# sourceMappingURL=context-dir.js.map

package/dist/commands/init/steps/docker-deploy.d.ts

@@ -0,0 +1,16 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 13: Scaffold Docker zero-downtime deploy.
+ *
+ * - When options.dockerDeploy is false, reports "skipped".
+ * - Resolves the deploy destination for the configured CI provider; reports
+ *   "error" when no destination/template exists for that provider.
+ * - If the destination file already exists, reports "done" with "already exists".
+ * - Otherwise renders the deploy workflow with options.dockerServiceName ?? "app"
+ *   and writes it (backing up any existing file).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export declare const stepDockerDeploy: StepFn;
+//# sourceMappingURL=docker-deploy.d.ts.map

package/dist/commands/init/steps/docker-deploy.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { backupIfExists, ensureDirExists } from "../../../lib/common.js";
+import { generateDeployWorkflow, getDeployDestination, } from "../../../lib/template.js";
+import { report } from "../report.js";
+/**
+ * Step 13: Scaffold Docker zero-downtime deploy.
+ *
+ * - When options.dockerDeploy is false, reports "skipped".
+ * - Resolves the deploy destination for the configured CI provider; reports
+ *   "error" when no destination/template exists for that provider.
+ * - If the destination file already exists, reports "done" with "already exists".
+ * - Otherwise renders the deploy workflow with options.dockerServiceName ?? "app"
+ *   and writes it (backing up any existing file).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 4 of 6).
+ */
+export const stepDockerDeploy = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { ciProvider } = options;
+    const stepId = "docker-deploy";
+    report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "running");
+    try {
+        if (options.dockerDeploy) {
+            const deployDest = getDeployDestination(ciProvider);
+            if (deployDest) {
+                const fullDest = path.join(projectDir, deployDest);
+                if (await fs.pathExists(fullDest)) {
+                    report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "done", "already exists");
+                }
+                else {
+                    const serviceName = options.dockerServiceName || "app";
+                    const content = await generateDeployWorkflow(ciProvider, serviceName);
+                    if (content) {
+                        if (!dryRun) {
+                            await backupIfExists(fullDest);
+                            await ensureDirExists(path.dirname(fullDest));
+                            await fs.writeFile(fullDest, content, "utf-8");
+                        }
+                        report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "done", dryRun ? `dry-run: would create ${deployDest}` : deployDest);
+                    }
+                    else {
+                        report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "error", `no deploy template for ${ciProvider}`);
+                    }
+                }
+            }
+            else {
+                report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "error", `no deploy destination for ${ciProvider}`);
+            }
+        }
+        else {
+            report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Scaffold Docker zero-downtime deploy", "error", String(e));
+    }
+};
+//# sourceMappingURL=docker-deploy.js.map

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

@@ -0,0 +1,15 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 9: Install GHAGGA review system.
+ *
+ * - When ghagga is false, reports "skipped".
+ * - Copies <MODULES_DIR>/ghagga → <project>/.javi-forge/modules/ghagga (no overwrite).
+ * - For GitHub provider, also copies the ghagga-review.yml caller workflow into
+ *   <project>/.github/workflows/.
+ * - If 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 3 of 6).
+ */
+export declare const stepGhagga: StepFn;
+//# sourceMappingURL=ghagga.d.ts.map

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

@@ -0,0 +1,58 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { FORGE_ROOT, MODULES_DIR } from "../../../constants.js";
+import { ensureDirExists } from "../../../lib/common.js";
+import { report } from "../report.js";
+/**
+ * Step 9: Install GHAGGA review system.
+ *
+ * - When ghagga is false, reports "skipped".
+ * - Copies <MODULES_DIR>/ghagga → <project>/.javi-forge/modules/ghagga (no overwrite).
+ * - For GitHub provider, also copies the ghagga-review.yml caller workflow into
+ *   <project>/.github/workflows/.
+ * - If 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 3 of 6).
+ */
+export const stepGhagga = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { ghagga, ciProvider } = options;
+    const stepId = "ghagga";
+    report(onStep, stepId, "Install GHAGGA review system", "running");
+    try {
+        if (ghagga) {
+            const ghaggaSrc = path.join(MODULES_DIR, "ghagga");
+            if (await fs.pathExists(ghaggaSrc)) {
+                if (!dryRun) {
+                    const ghaggaDest = path.join(projectDir, ".javi-forge", "modules", "ghagga");
+                    await ensureDirExists(ghaggaDest);
+                    await fs.copy(ghaggaSrc, ghaggaDest, {
+                        overwrite: false,
+                        errorOnExist: false,
+                    });
+                    // Copy ghagga caller workflow to CI provider location
+                    if (ciProvider === "github") {
+                        const workflowSrc = path.join(FORGE_ROOT, "templates", "github", "ghagga-review.yml");
+                        if (await fs.pathExists(workflowSrc)) {
+                            const workflowDest = path.join(projectDir, ".github", "workflows", "ghagga-review.yml");
+                            await ensureDirExists(path.dirname(workflowDest));
+                            await fs.copy(workflowSrc, workflowDest, { overwrite: false });
+                        }
+                    }
+                }
+                report(onStep, stepId, "Install GHAGGA review system", "done");
+            }
+            else {
+                report(onStep, stepId, "Install GHAGGA review system", "error", "module not found");
+            }
+        }
+        else {
+            report(onStep, stepId, "Install GHAGGA review system", "skipped", "not selected");
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Install GHAGGA review system", "error", String(e));
+    }
+};
+//# sourceMappingURL=ghagga.js.map

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

@@ -0,0 +1,25 @@
+import type { StepFn } from "../types.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 declare const stepGitInit: StepFn;
+/**
+ * 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 declare const stepGitHooks: StepFn;
+//# sourceMappingURL=git.d.ts.map

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