javi-forge 1.6.0 → 1.7.0

package/dist/commands/init.js

@@ -1,397 +1,52 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { backupIfExists, ensureDirExists } from '../lib/common.js';
-import { generateDependabotYml, generateCIWorkflow, getCIDestination } from '../lib/template.js';
-import { generateContextDir } from '../lib/context.js';
-import { generateClaudeMd } from '../lib/claudemd.js';
-import { FORGE_ROOT, MODULES_DIR, CI_LOCAL_DIR, } from '../constants.js';
-const execFileAsync = promisify(execFile);
-function report(onStep, id, label, status, detail) {
-    onStep({ id, label, status, detail });
-}
+import { ensureDirExists } from "../lib/common.js";
+import { stepAgentSkills } from "./init/steps/agent-skills.js";
+import { stepAISync } from "./init/steps/ai-sync.js";
+import { stepCITemplate, stepDependabot } from "./init/steps/ci.js";
+import { stepClaudeMd } from "./init/steps/claude-md.js";
+import { stepCodeGraph } from "./init/steps/code-graph.js";
+import { stepContextDir } from "./init/steps/context-dir.js";
+import { stepDockerDeploy } from "./init/steps/docker-deploy.js";
+import { stepGhagga } from "./init/steps/ghagga.js";
+import { stepGitHooks, stepGitInit } from "./init/steps/git.js";
+import { stepGitignore } from "./init/steps/gitignore.js";
+import { stepLocalAi } from "./init/steps/local-ai.js";
+import { stepManifest } from "./init/steps/manifest.js";
+import { stepMemory } from "./init/steps/memory.js";
+import { stepMock } from "./init/steps/mock.js";
+import { stepSDD } from "./init/steps/sdd.js";
+import { stepHookProfile, stepSecurityHooks } from "./init/steps/security.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 async function initProject(options, onStep) {
-    const { projectDir, projectName, stack, ciProvider, memory, aiSync, sdd, ghagga, contextDir, claudeMd, dryRun } = options;
+    const { projectDir, dryRun } = options;
     // Ensure project directory exists before any steps
     if (!dryRun && projectDir) {
         await ensureDirExists(projectDir);
     }
-    // ── Step 1: Initialize git ────────────────────────────────────────────────
-    const stepGit = 'git-init';
-    report(onStep, stepGit, '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, stepGit, 'Initialize git repository', 'done', 'initialized');
-        }
-        else {
-            report(onStep, stepGit, 'Initialize git repository', 'done', 'already exists');
-        }
-    }
-    catch (e) {
-        report(onStep, stepGit, 'Initialize git repository', 'error', String(e));
-    }
-    // ── Step 2: Configure git hooks path ──────────────────────────────────────
-    const stepHooks = 'git-hooks';
-    report(onStep, stepHooks, '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, stepHooks, 'Configure git hooks path', 'done', 'ci-local/hooks');
-        }
-        else {
-            report(onStep, stepHooks, 'Configure git hooks path', 'skipped', 'no ci-local dir');
-        }
-    }
-    catch (e) {
-        report(onStep, stepHooks, 'Configure git hooks path', 'error', String(e));
-    }
-    // ── Step 3: Copy CI template ──────────────────────────────────────────────
-    const stepCI = 'ci-template';
-    report(onStep, stepCI, `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, stepCI, `Copy ${ciProvider} CI workflow`, 'done', getCIDestination(ciProvider));
-        }
-        else {
-            report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'skipped', `no template for ${stack}`);
-        }
-    }
-    catch (e) {
-        report(onStep, stepCI, `Copy ${ciProvider} CI workflow`, 'error', String(e));
-    }
-    // ── Step 4: Generate .gitignore ───────────────────────────────────────────
-    const stepGitignore = 'gitignore';
-    report(onStep, stepGitignore, '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, stepGitignore, 'Generate .gitignore', 'done', 'from template');
-        }
-        else if (await fs.pathExists(dest)) {
-            report(onStep, stepGitignore, 'Generate .gitignore', 'done', 'already exists');
-        }
-        else {
-            report(onStep, stepGitignore, 'Generate .gitignore', 'skipped', 'no template');
-        }
-    }
-    catch (e) {
-        report(onStep, stepGitignore, 'Generate .gitignore', 'error', String(e));
-    }
-    // ── Step 5: Generate dependabot.yml ───────────────────────────────────────
-    const stepDeps = 'dependabot';
-    report(onStep, stepDeps, '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, stepDeps, 'Generate dependabot.yml', 'done');
-        }
-        else {
-            report(onStep, stepDeps, 'Generate dependabot.yml', 'skipped', `not needed for ${ciProvider}`);
-        }
-    }
-    catch (e) {
-        report(onStep, stepDeps, 'Generate dependabot.yml', 'error', String(e));
-    }
-    // ── Step 6: Install memory module ─────────────────────────────────────────
-    const stepMem = 'memory';
-    report(onStep, stepMem, `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, stepMem, `Install memory module: ${memory}`, 'done');
-            }
-            else {
-                report(onStep, stepMem, `Install memory module: ${memory}`, 'error', 'module not found');
-            }
-        }
-        else {
-            report(onStep, stepMem, `Install memory module: ${memory}`, 'skipped', 'none selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepMem, `Install memory module: ${memory}`, 'error', String(e));
-    }
-    // ── Step 7: AI config sync (delegated to javi-ai) ──────────────────────────
-    const stepAI = 'ai-sync';
-    report(onStep, stepAI, '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, stepAI, 'Sync AI config via javi-ai', 'error', 'javi-ai crashed. Run manually: npx javi-ai sync --project-dir . --target all');
-                    }
-                    else {
-                        report(onStep, stepAI, '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, stepAI, '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, stepAI, 'Sync AI config via javi-ai', 'error', msg);
-                    }
-                }
-            }
-            else {
-                report(onStep, stepAI, 'Sync AI config via javi-ai', 'done', 'dry-run: would run javi-ai sync --target all');
-            }
-        }
-        else {
-            report(onStep, stepAI, 'Sync AI config via javi-ai', 'skipped', 'not selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepAI, 'Sync AI config via javi-ai', 'error', String(e));
-    }
-    // ── Step 8: SDD (Spec-Driven Development) ─────────────────────────────────
-    const stepSDD = 'sdd';
-    report(onStep, stepSDD, '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, stepSDD, 'Set up SDD (openspec/)', 'done');
-        }
-        else {
-            report(onStep, stepSDD, 'Set up SDD (openspec/)', 'skipped', 'not selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepSDD, 'Set up SDD (openspec/)', 'error', String(e));
-    }
-    // ── Step 9: GHAGGA ────────────────────────────────────────────────────────
-    const stepGhagga = 'ghagga';
-    report(onStep, stepGhagga, '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, stepGhagga, 'Install GHAGGA review system', 'done');
-            }
-            else {
-                report(onStep, stepGhagga, 'Install GHAGGA review system', 'error', 'module not found');
-            }
-        }
-        else {
-            report(onStep, stepGhagga, 'Install GHAGGA review system', 'skipped', 'not selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepGhagga, 'Install GHAGGA review system', 'error', String(e));
-    }
-    // ── Step 10: Mock-first mode ───────────────────────────────────────────────
-    const stepMock = 'mock';
-    if (options.mock) {
-        report(onStep, stepMock, 'Configure mock-first mode', 'running');
-        try {
-            if (!dryRun) {
-                // Create .env.example with mock values
-                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
-`;
-                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, stepMock, 'Configure mock-first mode', 'done', '.env.example + .env with mock values');
-        }
-        catch (e) {
-            report(onStep, stepMock, 'Configure mock-first mode', 'error', String(e));
-        }
-    }
-    else {
-        report(onStep, stepMock, 'Configure mock-first mode', 'skipped', 'not selected');
-    }
-    // ── Step 11: Generate .context/ directory ──────────────────────────────────
-    const stepContext = 'context-dir';
-    report(onStep, stepContext, 'Generate .context/ directory', 'running');
-    try {
-        if (contextDir) {
-            const contextDirPath = path.join(projectDir, '.context');
-            if (await fs.pathExists(contextDirPath)) {
-                report(onStep, stepContext, '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, stepContext, 'Generate .context/ directory', 'done', dryRun ? 'dry-run: would generate .context/' : '.context/INDEX.md + summary.md');
-            }
-        }
-        else {
-            report(onStep, stepContext, 'Generate .context/ directory', 'skipped', 'not selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepContext, 'Generate .context/ directory', 'error', String(e));
-    }
-    // ── Step 12: Generate CLAUDE.md ────────────────────────────────────────────
-    const stepClaudeMd = 'claude-md';
-    report(onStep, stepClaudeMd, 'Generate CLAUDE.md', 'running');
-    try {
-        if (claudeMd) {
-            const claudeMdPath = path.join(projectDir, 'CLAUDE.md');
-            if (await fs.pathExists(claudeMdPath)) {
-                report(onStep, stepClaudeMd, 'Generate CLAUDE.md', 'done', 'already exists');
-            }
-            else {
-                if (!dryRun) {
-                    const content = generateClaudeMd(options);
-                    await fs.writeFile(claudeMdPath, content, 'utf-8');
-                }
-                report(onStep, stepClaudeMd, 'Generate CLAUDE.md', 'done', dryRun ? 'dry-run: would generate CLAUDE.md' : 'CLAUDE.md');
-            }
-        }
-        else {
-            report(onStep, stepClaudeMd, 'Generate CLAUDE.md', 'skipped', 'not selected');
-        }
-    }
-    catch (e) {
-        report(onStep, stepClaudeMd, 'Generate CLAUDE.md', 'error', String(e));
-    }
-    // ── Step 13: Write manifest ───────────────────────────────────────────────
-    const stepManifest = 'manifest';
-    report(onStep, stepManifest, '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'] : []),
-                ],
-            };
-            await fs.writeJson(path.join(manifestDir, 'manifest.json'), manifest, { spaces: 2 });
-        }
-        report(onStep, stepManifest, 'Write forge manifest', 'done', '.javi-forge/manifest.json');
-    }
-    catch (e) {
-        report(onStep, stepManifest, 'Write forge manifest', 'error', String(e));
-    }
+    // Shared context passed to every step.
+    const ctx = { options, projectDir, dryRun, onStep };
+    await stepGitInit(ctx);
+    await stepGitHooks(ctx);
+    await stepCITemplate(ctx);
+    await stepGitignore(ctx);
+    await stepDependabot(ctx);
+    await stepMemory(ctx);
+    await stepAISync(ctx);
+    await stepSDD(ctx);
+    await stepGhagga(ctx);
+    await stepMock(ctx);
+    await stepContextDir(ctx);
+    await stepClaudeMd(ctx);
+    await stepDockerDeploy(ctx);
+    await stepSecurityHooks(ctx);
+    await stepHookProfile(ctx);
+    await stepCodeGraph(ctx);
+    await stepLocalAi(ctx);
+    await stepAgentSkills(ctx);
+    await stepManifest(ctx);
 }
 //# sourceMappingURL=init.js.map

package/dist/commands/llmstxt.d.ts

@@ -1,4 +1,4 @@
-import type { InitStep } from '../types/index.js';
+import type { InitStep } from "../types/index.js";
 type StepCallback = (step: InitStep) => void;
 /**
  * Generate an llms.txt file — compact AI-friendly project notation.

package/dist/commands/llmstxt.js

@@ -1,7 +1,7 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { glob } from 'glob';
-import { detectStack } from '../lib/common.js';
+import path from "node:path";
+import fs from "fs-extra";
+import { glob } from "glob";
+import { detectStack } from "../lib/common.js";
 function report(onStep, id, label, status, detail) {
     onStep({ id, label, status, detail });
 }
@@ -10,53 +10,55 @@ function report(onStep, id, label, status, detail) {
  * Reduces token usage by ~75% compared to full README + docs.
  */
 export async function generateLlmsTxt(projectDir, dryRun, onStep) {
-    report(onStep, 'scan', 'Scan project structure', 'running');
+    report(onStep, "scan", "Scan project structure", "running");
     const detection = await detectStack(projectDir);
-    const stackLabel = detection?.stackType ?? 'unknown';
+    const stackLabel = detection?.stackType ?? "unknown";
     // Gather project info
     const name = path.basename(projectDir);
-    let description = '';
-    let version = '';
+    let description = "";
+    let version = "";
     let entryPoints = [];
     let dependencies = [];
     // Try package.json (Node)
-    const pkgPath = path.join(projectDir, 'package.json');
+    const pkgPath = path.join(projectDir, "package.json");
     if (await fs.pathExists(pkgPath)) {
         try {
             const pkg = await fs.readJson(pkgPath);
-            description = pkg.description ?? '';
-            version = pkg.version ?? '';
+            description = pkg.description ?? "";
+            version = pkg.version ?? "";
             entryPoints = pkg.main ? [pkg.main] : [];
             dependencies = Object.keys(pkg.dependencies ?? {}).slice(0, 15);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     // Scan source files
-    const sourceFiles = await glob('src/**/*.{ts,tsx,js,jsx,py,go,rs}', {
+    const sourceFiles = await glob("src/**/*.{ts,tsx,js,jsx,py,go,rs}", {
         cwd: projectDir,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
     });
     // Scan test files
-    const testFiles = await glob('**/*.{test,spec}.{ts,tsx,js,jsx,py}', {
+    const testFiles = await glob("**/*.{test,spec}.{ts,tsx,js,jsx,py}", {
         cwd: projectDir,
-        ignore: ['**/node_modules/**', '**/dist/**'],
+        ignore: ["**/node_modules/**", "**/dist/**"],
     });
-    report(onStep, 'scan', 'Scan project structure', 'done', `${sourceFiles.length} source, ${testFiles.length} test files`);
+    report(onStep, "scan", "Scan project structure", "done", `${sourceFiles.length} source, ${testFiles.length} test files`);
     // Build llms.txt content
-    report(onStep, 'generate', 'Generate llms.txt', 'running');
+    report(onStep, "generate", "Generate llms.txt", "running");
     const lines = [
         `# ${name}`,
-        '',
-        `> ${description || 'No description'}`,
-        '',
-        `- stack: ${stackLabel}${detection?.buildTool ? ` (${detection.buildTool})` : ''}`,
-        `- version: ${version || 'unknown'}`,
+        "",
+        `> ${description || "No description"}`,
+        "",
+        `- stack: ${stackLabel}${detection?.buildTool ? ` (${detection.buildTool})` : ""}`,
+        `- version: ${version || "unknown"}`,
         `- files: ${sourceFiles.length} source, ${testFiles.length} tests`,
-        '',
+        "",
     ];
     // Structure summary (compact)
     if (sourceFiles.length > 0) {
-        lines.push('## Structure');
+        lines.push("## Structure");
         const dirs = new Map();
         for (const f of sourceFiles) {
             const dir = path.dirname(f);
@@ -65,28 +67,28 @@ export async function generateLlmsTxt(projectDir, dryRun, onStep) {
         for (const [dir, count] of [...dirs.entries()].sort().slice(0, 20)) {
             lines.push(`- ${dir}/ (${count})`);
         }
-        lines.push('');
+        lines.push("");
     }
     // Dependencies (compact — name only, no versions)
     if (dependencies.length > 0) {
-        lines.push('## Dependencies');
-        lines.push(dependencies.join(', '));
-        lines.push('');
+        lines.push("## Dependencies");
+        lines.push(dependencies.join(", "));
+        lines.push("");
     }
     // Entry points
     if (entryPoints.length > 0) {
-        lines.push('## Entry');
+        lines.push("## Entry");
         for (const ep of entryPoints) {
             lines.push(`- ${ep}`);
         }
-        lines.push('');
+        lines.push("");
     }
-    const content = lines.join('\n');
+    const content = lines.join("\n");
     const tokenEstimate = Math.ceil(content.length / 4);
     if (!dryRun) {
-        await fs.writeFile(path.join(projectDir, 'llms.txt'), content, 'utf-8');
+        await fs.writeFile(path.join(projectDir, "llms.txt"), content, "utf-8");
     }
-    report(onStep, 'generate', 'Generate llms.txt', 'done', dryRun
+    report(onStep, "generate", "Generate llms.txt", "done", dryRun
         ? `dry-run: ~${tokenEstimate} tokens (${content.length} chars)`
         : `written — ~${tokenEstimate} tokens (${content.length} chars)`);
 }

package/dist/commands/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { InitStep } from '../types/index.js';
+import type { InitStep } from "../types/index.js";
 type StepCallback = (step: InitStep) => void;
 /**
  * Add (install) a plugin from a GitHub source.
@@ -36,5 +36,14 @@ export declare function runPluginExportCodex(name: string, onStep: StepCallback)
  * Import an Agent Skills spec package and convert to javi-forge plugin format.
  */
 export declare function runPluginImport(sourceDir: string, dryRun: boolean, onStep: StepCallback): Promise<void>;
+/**
+ * Generate a project-level skills.json from all installed plugins.
+ * Makes the project discoverable by `npx skills add` and 40+ AI agents.
+ */
+export declare function runPluginExportSkillsJson(projectDir: string, dryRun: boolean, onStep: StepCallback): Promise<void>;
+/**
+ * Generate a global skills.json from all globally installed plugins.
+ */
+export declare function runPluginExportGlobalSkillsJson(dryRun: boolean, onStep: StepCallback): Promise<void>;
 export {};
 //# sourceMappingURL=plugin.d.ts.map