javi-forge 1.6.0 → 1.6.1

package/dist/index.js

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
-import path from 'path';
-import React from 'react';
-import { render } from 'ink';
-import { PassThrough } from 'node:stream';
-import meow from 'meow';
-import updateNotifier from 'update-notifier';
-import { createRequire } from 'module';
-import App from './ui/App.js';
-import Doctor from './ui/Doctor.js';
-import AnalyzeUI from './ui/AnalyzeUI.js';
-import Plugin from './ui/Plugin.js';
-import Skills from './ui/Skills.js';
-import LlmsTxt from './ui/LlmsTxt.js';
-import CI from './ui/CI.js';
-import { CIProvider as CIContextProvider } from './ui/CIContext.js';
+import { PassThrough } from "node:stream";
+import { render } from "ink";
+import meow from "meow";
+import { createRequire } from "module";
+import path from "path";
+import React from "react";
+import updateNotifier from "update-notifier";
+import AnalyzeUI from "./ui/AnalyzeUI.js";
+import App from "./ui/App.js";
+import AutoSkills from "./ui/AutoSkills.js";
+import CI from "./ui/CI.js";
+import { CIProvider as CIContextProvider } from "./ui/CIContext.js";
+import Doctor from "./ui/Doctor.js";
+import LlmsTxt from "./ui/LlmsTxt.js";
+import Plugin from "./ui/Plugin.js";
+import Skills from "./ui/Skills.js";
 // Check for updates in background (non-blocking, cached 24h)
 const _require = createRequire(import.meta.url);
-const pkg = _require('../package.json');
+const pkg = _require("../package.json");
 updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 * 24 }).notify();
 const cli = meow(`
   Usage
@@ -26,8 +27,12 @@ const cli = meow(`
     init              Bootstrap a new project (default)
     ci                Run CI simulation (lint + compile + test + security + ghagga)
     tdd init          Install TDD-enforcing pre-commit hook (auto-detects stack)
+    tdd pipeline      Install TDD pipeline pre-push hook (--mode strict|warn)
     analyze           Run repoforge skills analysis
     doctor            Show health report
+    workflow show     Render a workflow graph as ASCII (--template <name> or file path)
+    workflow validate Validate project state against a workflow graph
+    workflow list     List available workflows and built-in templates
     plugin add        Install a plugin from GitHub (org/repo)
     plugin remove     Remove an installed plugin
     plugin list       List installed plugins
@@ -35,14 +40,21 @@ const cli = meow(`
     plugin validate   Validate a local plugin directory
     plugin sync       Auto-detect and wire installed plugins
     plugin export     Export plugin to Agent Skills spec format (skills.json)
+    plugin export     --codex: Export plugin to Codex-compatible TOML subagent files
+    plugin export-skills  Generate aggregated skills.json from all installed plugins
+    plugin export-skills global  Generate global skills.json from all globally installed plugins
     plugin import     Import an Agent Skills spec package as a javi-forge plugin
     skills doctor     Show skills health report (add --deep for conflict detection)
     skills budget     Show token cost of loaded skills (add -b N for custom budget)
     skills score      Score a skill on quality dimensions (completeness, clarity, testability, token-efficiency)
     skills benchmark  Benchmark a skill with structural quality checks
-    security baseline Create security baseline from current audit findings
-    security check    Check for regressions against baseline (exits non-zero if found)
-    security update   Re-snapshot baseline (acknowledge current vulns)
+    skills auto       Auto-detect project stack and suggest/install matching AI skills
+    skills auto-install  Alias for skills auto
+    skill publish     Package a skill directory for marketplace distribution (generates plugin.json)
+    security baseline   Create security baseline from current audit findings
+    security check      Check for regressions against baseline (exits non-zero if found)
+    security update     Re-snapshot baseline (acknowledge current vulns)
+    security allowlist  Add all current findings to the allowlist (suppress in future checks)
     llms-txt          Generate AI-friendly llms.txt for current project
 
   Options
@@ -53,10 +65,13 @@ const cli = meow(`
     --project-name  Project name (skips name prompt)
     --ghagga        Enable GHAGGA review system
     --mock          Enable mock-first mode (no real API keys needed)
+    --local-ai      Include local AI dev stack (Ollama + Docker Compose)
     --batch         Non-interactive mode (auto-proceed, no keyboard input)
     --deep          Enable deep analysis (conflict + duplicate detection)
     --budget, -b    Token budget limit for skills (default: 8000)
     --skills-dir    Custom skills directory path
+    --author        Author name for skill publish
+    --repo          Repository URL for skill publish
     --version       Show version
     --help          Show this help
 
@@ -91,68 +106,107 @@ const cli = meow(`
 `, {
     importMeta: import.meta,
     flags: {
-        dryRun: { type: 'boolean', default: false },
-        stack: { type: 'string', default: '' },
-        ci: { type: 'string', default: '' },
-        memory: { type: 'string', default: '' },
-        projectName: { type: 'string', default: '' },
-        ghagga: { type: 'boolean', default: false },
-        mock: { type: 'boolean', default: false },
-        batch: { type: 'boolean', default: false },
+        dryRun: { type: "boolean", default: false },
+        stack: { type: "string", default: "" },
+        ci: { type: "string", default: "" },
+        memory: { type: "string", default: "" },
+        projectName: { type: "string", default: "" },
+        ghagga: { type: "boolean", default: false },
+        mock: { type: "boolean", default: false },
+        localAi: { type: "boolean", default: false },
+        batch: { type: "boolean", default: false },
         // CI flags
-        quick: { type: 'boolean', default: false },
-        shell: { type: 'boolean', default: false },
-        detect: { type: 'boolean', default: false },
-        docker: { type: 'boolean', default: true },
-        ciGhagga: { type: 'boolean', default: true },
-        security: { type: 'boolean', default: true },
-        timeout: { type: 'number', default: 600 },
+        quick: { type: "boolean", default: false },
+        shell: { type: "boolean", default: false },
+        detect: { type: "boolean", default: false },
+        docker: { type: "boolean", default: true },
+        ciGhagga: { type: "boolean", default: true },
+        security: { type: "boolean", default: true },
+        timeout: { type: "number", default: 600 },
+        // Security check flags
+        minSeverity: { type: "string", default: "low" },
+        staleDays: { type: "number", default: 30 },
+        json: { type: "boolean", default: false },
+        // Plugin flags
+        codex: { type: "boolean", default: false },
         // Skills flags
-        deep: { type: 'boolean', default: false },
-        budget: { type: 'number', shortFlag: 'b', default: 8000 },
-        skillsDir: { type: 'string', default: '' },
-    }
+        deep: { type: "boolean", default: false },
+        budget: { type: "number", shortFlag: "b", default: 8000 },
+        skillsDir: { type: "string", default: "" },
+        // Skill publish flags
+        author: { type: "string", default: "" },
+        repo: { type: "string", default: "" },
+        // Workflow flags
+        template: { type: "string", default: "" },
+    },
 });
-const subcommand = cli.input[0] ?? 'init';
-const VALID_STACKS = ['node', 'python', 'go', 'rust', 'java-gradle', 'java-maven', 'elixir'];
-const VALID_CI = ['github', 'gitlab', 'woodpecker'];
-const VALID_MEMORY = ['engram', 'obsidian-brain', 'memory-simple', 'none'];
-const isCI = cli.flags.batch || process.env['CI'] === '1' || process.env['CI'] === 'true';
+const subcommand = cli.input[0] ?? "init";
+const VALID_STACKS = [
+    "node",
+    "python",
+    "go",
+    "rust",
+    "java-gradle",
+    "java-maven",
+    "elixir",
+];
+const VALID_CI = ["github", "gitlab", "woodpecker"];
+const VALID_MEMORY = ["engram", "obsidian-brain", "memory-simple", "none"];
+const isCI = cli.flags.batch || process.env["CI"] === "1" || process.env["CI"] === "true";
 // When stdin doesn't support raw mode (pipes, subprocesses, CI), provide a fake
 // stdin stream so Ink doesn't crash trying to enable raw mode on a non-TTY pipe.
 const isTTY = process.stdin.isTTY === true;
 const fakeStdin = new PassThrough();
-Object.defineProperty(fakeStdin, 'isTTY', { value: false });
+Object.defineProperty(fakeStdin, "isTTY", { value: false });
 const inkStdin = isTTY ? process.stdin : fakeStdin;
 switch (subcommand) {
-    case 'tdd': {
-        if (cli.input[1] === 'init') {
-            const { installTddHooks } = await import('./commands/tdd.js');
+    case "tdd": {
+        if (cli.input[1] === "init") {
+            const { installTddHooks } = await import("./commands/tdd.js");
             const { installed, errors } = await installTddHooks(process.cwd());
             if (installed.length > 0) {
-                console.log(`\u2713 Installed TDD hooks: ${installed.join(', ')}`);
-                console.log('  Pre-commit hook enforces tests must pass before commit');
+                console.log(`\u2713 Installed TDD hooks: ${installed.join(", ")}`);
+                console.log("  Pre-commit hook enforces tests must pass before commit");
             }
             for (const err of errors) {
                 console.error(`\u2717 ${err}`);
             }
             process.exit(errors.length > 0 ? 1 : 0);
         }
+        else if (cli.input[1] === "pipeline") {
+            const { installTddPipelineHook } = await import("./commands/tdd-pipeline.js");
+            const mode = cli.flags.mode === "warn"
+                ? "warn"
+                : "strict";
+            const result = await installTddPipelineHook(process.cwd(), mode);
+            if (result.installed.length > 0) {
+                console.log(`\u2713 Installed TDD pipeline hook: ${result.installed.join(", ")} [${result.mode}]`);
+                console.log(`  Pre-push hook enforces TDD pipeline (${result.mode} mode)`);
+            }
+            for (const skip of result.skipped) {
+                console.log(`\u26A0 ${skip}`);
+            }
+            for (const err of result.errors) {
+                console.error(`\u2717 ${err}`);
+            }
+            process.exit(result.errors.length > 0 ? 1 : 0);
+        }
         else {
-            console.error('Usage: javi-forge tdd init');
-            console.error('  init  Install TDD-enforcing pre-commit hook');
+            console.error("Usage: javi-forge tdd <command>");
+            console.error("  init      Install TDD-enforcing pre-commit hook");
+            console.error("  pipeline  Install TDD pipeline pre-push hook (--mode strict|warn)");
             process.exit(1);
         }
         break;
     }
-    case 'ci': {
+    case "ci": {
         // Sub-command: javi-forge ci init → install git hooks
-        if (cli.input[1] === 'init') {
-            const { installCIHooks } = await import('./commands/ci.js');
+        if (cli.input[1] === "init") {
+            const { installCIHooks } = await import("./commands/ci.js");
             const { installed, errors } = await installCIHooks(process.cwd());
             if (installed.length > 0) {
-                console.log(`✓ Installed git hooks: ${installed.join(', ')}`);
-                console.log('  Hooks call javi-forge ci (with npx fallback)');
+                console.log(`✓ Installed git hooks: ${installed.join(", ")}`);
+                console.log("  Hooks call javi-forge ci (with npx fallback)");
             }
             for (const err of errors) {
                 console.error(`✗ ${err}`);
@@ -160,62 +214,153 @@ switch (subcommand) {
             process.exit(errors.length > 0 ? 1 : 0);
             break;
         }
-        const ciMode = cli.flags.detect ? 'detect'
-            : cli.flags.shell ? 'shell'
-                : cli.flags.quick ? 'quick'
-                    : 'full';
+        const ciMode = cli.flags.detect
+            ? "detect"
+            : cli.flags.shell
+                ? "shell"
+                : cli.flags.quick
+                    ? "quick"
+                    : "full";
         render(React.createElement(CIContextProvider, { isCI: true },
             React.createElement(CI, { projectDir: process.cwd(), mode: ciMode, noDocker: !cli.flags.docker, noGhagga: !cli.flags.ciGhagga, noSecurity: !cli.flags.security, timeout: cli.flags.timeout })), { stdin: inkStdin });
         break;
     }
-    case 'doctor': {
+    case "doctor": {
         render(React.createElement(CIContextProvider, { isCI: isCI },
             React.createElement(Doctor, null)), { stdin: inkStdin });
         break;
     }
-    case 'analyze': {
+    case "analyze": {
         render(React.createElement(CIContextProvider, { isCI: isCI },
             React.createElement(AnalyzeUI, { dryRun: cli.flags.dryRun })), { stdin: inkStdin });
         break;
     }
-    case 'llms-txt': {
+    case "workflow": {
+        const workflowAction = cli.input[1];
+        const VALID_WORKFLOW_ACTIONS = ["show", "validate", "list"];
+        if (!workflowAction || !VALID_WORKFLOW_ACTIONS.includes(workflowAction)) {
+            console.error("Usage: javi-forge workflow <show|validate|list>");
+            console.error("  show      Render a workflow graph as ASCII");
+            console.error("  validate  Validate project state against a workflow graph");
+            console.error("  list      List available workflows and built-in templates");
+            console.error("");
+            console.error("  Options:");
+            console.error("    --template <name>  Use a built-in template (ci-pipeline, release, feature-flow)");
+            console.error("    <file>             Path to a .dot or .mermaid file");
+            process.exit(1);
+            break;
+        }
+        const { runWorkflowShow, runWorkflowValidate, runWorkflowList } = await import("./commands/workflow.js");
+        const workflowTarget = cli.input[2];
+        const workflowTemplate = cli.flags.template || undefined;
+        const onStep = (step) => {
+            const icon = step.status === "done"
+                ? "\u2713"
+                : step.status === "error"
+                    ? "\u2717"
+                    : "\u25CB";
+            console.log(`${icon} ${step.label}`);
+            if (step.detail)
+                console.log(`  ${step.detail}`);
+        };
+        try {
+            if (workflowAction === "show") {
+                const output = await runWorkflowShow(process.cwd(), onStep, {
+                    target: workflowTarget,
+                    template: workflowTemplate,
+                });
+                if (output)
+                    console.log("\n" + output);
+                else
+                    process.exit(1);
+            }
+            else if (workflowAction === "validate") {
+                const output = await runWorkflowValidate(process.cwd(), onStep, {
+                    target: workflowTarget,
+                    template: workflowTemplate,
+                });
+                if (output)
+                    console.log("\n" + output);
+                else
+                    process.exit(1);
+            }
+            else {
+                const output = await runWorkflowList(process.cwd(), onStep);
+                console.log("\n" + output);
+            }
+        }
+        catch (e) {
+            console.error(`\u2717 ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+        }
+        break;
+    }
+    case "llms-txt": {
         render(React.createElement(CIContextProvider, { isCI: isCI },
             React.createElement(LlmsTxt, { projectDir: process.cwd(), dryRun: cli.flags.dryRun })), { stdin: inkStdin });
         break;
     }
-    case 'plugin': {
+    case "plugin": {
         const pluginAction = cli.input[1];
-        const VALID_PLUGIN_ACTIONS = ['add', 'remove', 'list', 'search', 'validate', 'sync', 'export', 'import'];
-        const action = pluginAction && VALID_PLUGIN_ACTIONS.includes(pluginAction) ? pluginAction : 'list';
+        const VALID_PLUGIN_ACTIONS = [
+            "add",
+            "remove",
+            "list",
+            "search",
+            "validate",
+            "sync",
+            "export",
+            "import",
+            "export-skills",
+        ];
+        const action = pluginAction && VALID_PLUGIN_ACTIONS.includes(pluginAction)
+            ? pluginAction
+            : "list";
         const target = cli.input[2];
         render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(Plugin, { action: action, target: target, dryRun: cli.flags.dryRun })), { stdin: inkStdin });
+            React.createElement(Plugin, { action: action, target: target, dryRun: cli.flags.dryRun, codex: cli.flags.codex })), { stdin: inkStdin });
         break;
     }
-    case 'skills': {
+    case "skills": {
         const skillsAction = cli.input[1];
-        const VALID_SKILLS_ACTIONS = ['doctor', 'budget', 'score', 'benchmark'];
+        const VALID_SKILLS_ACTIONS = [
+            "doctor",
+            "budget",
+            "score",
+            "benchmark",
+            "auto",
+            "auto-install",
+        ];
         if (!skillsAction || !VALID_SKILLS_ACTIONS.includes(skillsAction)) {
-            console.error('Usage: javi-forge skills <doctor|budget|score|benchmark>');
-            console.error('  doctor     Show skills health report (add --deep for conflict detection)');
-            console.error('  budget     Show token cost of loaded skills (add -b N for custom budget)');
-            console.error('  score      Score a skill on quality dimensions (0-100)');
-            console.error('  benchmark  Benchmark a skill with structural quality checks');
+            console.error("Usage: javi-forge skills <doctor|budget|score|benchmark|auto>");
+            console.error("  doctor        Show skills health report (add --deep for conflict detection)");
+            console.error("  budget        Show token cost of loaded skills (add -b N for custom budget)");
+            console.error("  score         Score a skill on quality dimensions (0-100)");
+            console.error("  benchmark     Benchmark a skill with structural quality checks");
+            console.error("  auto          Auto-detect project stack and suggest/install matching AI skills");
+            console.error("  auto-install  Alias for auto");
             process.exit(1);
             break;
         }
+        // Auto / auto-install: render interactive Ink UI
+        if (skillsAction === "auto" || skillsAction === "auto-install") {
+            render(React.createElement(CIContextProvider, { isCI: isCI },
+                React.createElement(AutoSkills, { projectDir: process.cwd(), skillsDir: cli.flags.skillsDir || undefined, dryRun: cli.flags.dryRun })), { stdin: inkStdin });
+            break;
+        }
         // Score and benchmark are non-interactive CLI commands
-        if (skillsAction === 'score' || skillsAction === 'benchmark') {
+        if (skillsAction === "score" || skillsAction === "benchmark") {
             const targetSkill = cli.input[2];
             if (!targetSkill) {
                 console.error(`Usage: javi-forge skills ${skillsAction} <skill-name>`);
                 process.exit(1);
                 break;
             }
-            const skillsDir = cli.flags.skillsDir || path.join(process.env['HOME'] ?? '~', '.claude', 'skills');
-            const skillPath = path.join(skillsDir, targetSkill, 'SKILL.md');
-            if (skillsAction === 'score') {
-                const { scoreSkill } = await import('./commands/skills.js');
+            const skillsDir = cli.flags.skillsDir ||
+                path.join(process.env["HOME"] ?? "~", ".claude", "skills");
+            const skillPath = path.join(skillsDir, targetSkill, "SKILL.md");
+            if (skillsAction === "score") {
+                const { scoreSkill } = await import("./commands/skills.js");
                 const result = await scoreSkill(skillPath, cli.flags.budget);
                 if (!result) {
                     console.error(`\u2717 Skill not found: ${skillPath}`);
@@ -227,13 +372,17 @@ switch (subcommand) {
                 console.log(`  Clarity:           ${result.clarity}/100`);
                 console.log(`  Testability:       ${result.testability}/100`);
                 console.log(`  Token Efficiency:  ${result.tokenEfficiency}/100`);
+                console.log(`  Safety:            ${result.safety}/100`);
+                console.log(`  Agent Readiness:   ${result.agentReadiness}/100`);
+                console.log(`  ─────────────────────────`);
                 console.log(`  Overall:           ${result.overall}/100`);
+                console.log(`  Grade:             ${result.grade}`);
                 console.log(`  Threshold:         ${result.threshold}`);
-                console.log(`  Status:            ${result.passing ? '\u2713 PASSING' : '\u2717 FAILING'}`);
+                console.log(`  Status:            ${result.passing ? "\u2713 PASSING" : "\u2717 FAILING"}`);
                 process.exit(result.passing ? 0 : 1);
             }
             else {
-                const { benchmarkSkill } = await import('./commands/skills.js');
+                const { benchmarkSkill } = await import("./commands/skills.js");
                 const result = await benchmarkSkill(skillPath);
                 if (!result) {
                     console.error(`\u2717 Skill not found: ${skillPath}`);
@@ -242,8 +391,8 @@ switch (subcommand) {
                 }
                 console.log(`\nBenchmark: ${result.skillName}`);
                 for (const check of result.checks) {
-                    const icon = check.passed ? '\u2713' : '\u2717';
-                    console.log(`  ${icon} ${check.name}${check.detail ? ` — ${check.detail}` : ''}`);
+                    const icon = check.passed ? "\u2713" : "\u2717";
+                    console.log(`  ${icon} ${check.name}${check.detail ? ` — ${check.detail}` : ""}`);
                 }
                 console.log(`\n  Pass rate: ${result.passRate}%`);
                 process.exit(result.passRate >= 50 ? 0 : 1);
@@ -255,30 +404,91 @@ switch (subcommand) {
             React.createElement(Skills, { mode: skillsMode, budget: cli.flags.budget, deep: cli.flags.deep, skillsDir: cli.flags.skillsDir || undefined })), { stdin: inkStdin });
         break;
     }
-    case 'security': {
+    case "skill": {
+        const skillAction = cli.input[1];
+        if (skillAction !== "publish") {
+            console.error("Usage: javi-forge skill <publish>");
+            console.error("  publish  Package a skill directory for marketplace distribution");
+            process.exit(1);
+            break;
+        }
+        const targetDir = cli.input[2] ?? process.cwd();
+        const { publishSkill } = await import("./lib/skill-publish.js");
+        const result = await publishSkill({
+            skillDir: path.resolve(targetDir),
+            author: cli.flags.author || undefined,
+            repository: cli.flags.repo || undefined,
+            dryRun: cli.flags.dryRun,
+        });
+        if (result.success) {
+            console.log(`\u2713 Published: ${result.manifest?.name}@${result.manifest?.version}`);
+            console.log(`  plugin.json: ${result.pluginJsonPath}`);
+            if (result.manifest?.tags?.length) {
+                console.log(`  tags: ${result.manifest.tags.join(", ")}`);
+            }
+            if (cli.flags.dryRun) {
+                console.log("  (dry-run: no files written)");
+            }
+        }
+        else {
+            console.error(`\u2717 ${result.error}`);
+            process.exit(1);
+        }
+        break;
+    }
+    case "security": {
         const securityAction = cli.input[1];
-        const VALID_SECURITY_ACTIONS = ['baseline', 'check', 'update'];
+        const VALID_SECURITY_ACTIONS = ["baseline", "check", "update", "allowlist"];
         if (!securityAction || !VALID_SECURITY_ACTIONS.includes(securityAction)) {
-            console.error('Usage: javi-forge security <baseline|check|update>');
-            console.error('  baseline  Create security baseline from current audit findings');
-            console.error('  check     Check for regressions against baseline');
-            console.error('  update    Re-snapshot baseline (acknowledge current vulns)');
+            console.error("Usage: javi-forge security <baseline|check|update|allowlist>");
+            console.error("  baseline   Create security baseline from current audit findings");
+            console.error("  check      Check for regressions against baseline (exits non-zero if found)");
+            console.error("  update     Re-snapshot baseline (acknowledge current vulns)");
+            console.error("  allowlist  Add all current findings to the allowlist (suppress in future checks)");
+            console.error("");
+            console.error("  Options (check mode):");
+            console.error("    --min-severity <level>  Only fail on regressions >= level (critical|high|moderate|low|info)");
+            console.error("    --stale-days <N>        Warn if baseline older than N days (default: 30)");
+            console.error("    --json                  Output result as JSON (for CI integration)");
             process.exit(1);
             break;
         }
-        const { runSecurity } = await import('./commands/security.js');
+        const { runSecurity } = await import("./commands/security.js");
         const mode = securityAction;
+        const rawMinSev = cli.flags["minSeverity"];
+        const validSeverities = [
+            "critical",
+            "high",
+            "moderate",
+            "low",
+            "info",
+        ];
+        const checkOptions = {
+            minSeverity: (rawMinSev && validSeverities.includes(rawMinSev)
+                ? rawMinSev
+                : "low"),
+            staleDays: cli.flags["staleDays"],
+        };
+        const jsonOutput = !!cli.flags["json"];
         try {
             const result = await runSecurity(mode, process.cwd(), (step) => {
-                const icon = step.status === 'done' ? '\u2713'
-                    : step.status === 'error' ? '\u2717'
-                        : step.status === 'skipped' ? '-'
-                            : '\u25CB';
+                if (jsonOutput)
+                    return; // suppress step output in JSON mode
+                const icon = step.status === "done"
+                    ? "\u2713"
+                    : step.status === "error"
+                        ? "\u2717"
+                        : step.status === "skipped"
+                            ? "-"
+                            : "\u25CB";
                 console.log(`${icon} ${step.label}`);
                 if (step.detail)
                     console.log(`  ${step.detail}`);
-            });
-            if (mode === 'check' && result && result.regressions.length > 0) {
+            }, checkOptions);
+            if (jsonOutput && result) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            if (mode === "check" && result && result.filteredRegressions.length > 0) {
                 process.exit(1);
             }
         }
@@ -287,7 +497,7 @@ switch (subcommand) {
         }
         break;
     }
-    case 'init':
+    case "init":
     default: {
         const presetStack = VALID_STACKS.includes(cli.flags.stack)
             ? cli.flags.stack
@@ -300,7 +510,7 @@ switch (subcommand) {
             : undefined;
         const presetName = cli.flags.projectName || undefined;
         render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(App, { dryRun: cli.flags.dryRun, presetStack: presetStack, presetCI: presetCI, presetMemory: presetMemory, presetName: presetName, presetGhagga: cli.flags.ghagga, presetMock: cli.flags.mock ?? false })), { stdin: inkStdin });
+            React.createElement(App, { dryRun: cli.flags.dryRun, presetStack: presetStack, presetCI: presetCI, presetMemory: presetMemory, presetName: presetName, presetGhagga: cli.flags.ghagga, presetMock: cli.flags.mock ?? false, presetLocalAi: cli.flags.localAi ?? false })), { stdin: inkStdin });
         break;
     }
 }

package/dist/lib/agent-skills.d.ts

@@ -1,4 +1,4 @@
-import type { PluginManifest, AgentSkillsManifest } from '../types/index.js';
+import type { AgentSkillsManifest, AggregatedSkillsManifest, InstalledPlugin, PluginManifest } from "../types/index.js";
 /**
  * Convert a javi-forge PluginManifest to an Agent Skills spec manifest.
  */
@@ -35,4 +35,39 @@ export declare function importAgentSkillsPackage(sourceDir: string, options?: {
     name?: string;
     error?: string;
 }>;
+/**
+ * Aggregate multiple installed plugins into a single Agent Skills spec manifest.
+ * This enables the entire registry (or a project's installed plugins) to be
+ * discoverable via `npx skills add` by any of the 40+ compatible AI agents.
+ *
+ * Pure function — no I/O.
+ */
+export declare function aggregatePluginsToSkillsJson(plugins: InstalledPlugin[], registryName?: string, registryVersion?: string): AggregatedSkillsManifest;
+/**
+ * Generate a project-level skills.json from all installed plugins in a project.
+ * Writes the aggregated manifest to the project's .javi-forge/ directory.
+ */
+export declare function generateProjectSkillsJson(projectDir: string, options?: {
+    dryRun?: boolean;
+    registryName?: string;
+}): Promise<{
+    success: boolean;
+    path?: string;
+    skillCount: number;
+    pluginCount: number;
+    error?: string;
+}>;
+/**
+ * Generate a skills.json from all globally installed plugins.
+ * Writes to the global plugins directory.
+ */
+export declare function generateGlobalSkillsJson(options?: {
+    dryRun?: boolean;
+}): Promise<{
+    success: boolean;
+    path?: string;
+    skillCount: number;
+    pluginCount: number;
+    error?: string;
+}>;
 //# sourceMappingURL=agent-skills.d.ts.map