javi-forge 1.6.0 → 1.7.0

package/dist/index.js

@@ -1,306 +1,69 @@
 #!/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 { createRequire } from "node:module";
+import meow from "meow";
+import { handleCi } from "./cli/dispatch/ci.js";
+import { handleSecurity } from "./cli/dispatch/security.js";
+import { handleAnalyze, handleDoctor, handleInitDefault, handleLlmsTxt, handlePlugin, } from "./cli/dispatch/simple-renderers.js";
+import { handleSkillPublish } from "./cli/dispatch/skill-publish.js";
+import { handleSkillsCmd } from "./cli/dispatch/skills-cmd.js";
+import { handleTdd } from "./cli/dispatch/tdd.js";
+import { handleWorkflow } from "./cli/dispatch/workflow.js";
+import { FLAGS_SCHEMA, HELP_TEXT } from "./cli/help.js";
+import { createInkStdin, detectCI, setupUpdateNotifier, } from "./cli/runtime.js";
 // Check for updates in background (non-blocking, cached 24h)
 const _require = createRequire(import.meta.url);
-const pkg = _require('../package.json');
-updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 * 24 }).notify();
-const cli = meow(`
-  Usage
-    $ javi-forge [command] [options]
-
-  Commands
-    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)
-    analyze           Run repoforge skills analysis
-    doctor            Show health report
-    plugin add        Install a plugin from GitHub (org/repo)
-    plugin remove     Remove an installed plugin
-    plugin list       List installed plugins
-    plugin search     Search the plugin registry
-    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 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)
-    llms-txt          Generate AI-friendly llms.txt for current project
-
-  Options
-    --dry-run       Preview changes without writing files
-    --stack         Project stack (node, python, go, rust, java-gradle, java-maven, elixir)
-    --ci            CI provider (github, gitlab, woodpecker)
-    --memory        Memory module (engram, obsidian-brain, memory-simple, none)
-    --project-name  Project name (skips name prompt)
-    --ghagga        Enable GHAGGA review system
-    --mock          Enable mock-first mode (no real API keys needed)
-    --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
-    --version       Show version
-    --help          Show this help
-
-  CI options (javi-forge ci)
-    --quick         Lint + compile only (fast, for pre-commit)
-    --shell         Open interactive shell in CI container
-    --detect        Show detected stack and exit
-    --no-docker     Run commands natively (no Docker)
-    --no-ci-ghagga  Skip GHAGGA review
-    --no-security   Skip Semgrep security scan
-    --timeout N     Per-step timeout in seconds (default: 600)
-
-  CI hooks (javi-forge ci init)
-    Install git hooks that call javi-forge ci.
-    No files copied — hooks reference the global CLI.
-
-  Examples
-    $ javi-forge
-    $ javi-forge init --dry-run
-    $ javi-forge init --stack node --ci github
-    $ javi-forge ci
-    $ javi-forge ci init
-    $ javi-forge tdd init
-    $ javi-forge ci --quick
-    $ javi-forge ci --no-ci-ghagga --no-security
-    $ javi-forge ci --no-docker
-    $ javi-forge ci --shell
-    $ javi-forge analyze
-    $ javi-forge doctor
-    $ javi-forge plugin add mapbox/agent-skills
-    $ javi-forge plugin list
-`, {
+const pkg = _require("../package.json");
+setupUpdateNotifier(pkg);
+const cli = meow(HELP_TEXT, {
     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 },
-        // 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 },
-        // Skills flags
-        deep: { type: 'boolean', default: false },
-        budget: { type: 'number', shortFlag: 'b', default: 8000 },
-        skillsDir: { type: 'string', default: '' },
-    }
+    flags: FLAGS_SCHEMA,
 });
-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 });
-const inkStdin = isTTY ? process.stdin : fakeStdin;
+const subcommand = cli.input[0] ?? "init";
+const isCI = detectCI(cli.flags);
+const inkStdin = createInkStdin();
 switch (subcommand) {
-    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');
-            }
-            for (const err of errors) {
-                console.error(`\u2717 ${err}`);
-            }
-            process.exit(errors.length > 0 ? 1 : 0);
-        }
-        else {
-            console.error('Usage: javi-forge tdd init');
-            console.error('  init  Install TDD-enforcing pre-commit hook');
-            process.exit(1);
-        }
+    case "tdd": {
+        await handleTdd(cli);
+        break;
+    }
+    case "ci": {
+        await handleCi(cli, { inkStdin, isCI });
+        break;
+    }
+    case "doctor": {
+        handleDoctor(cli, { inkStdin, isCI });
         break;
     }
-    case 'ci': {
-        // Sub-command: javi-forge ci init → install git hooks
-        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)');
-            }
-            for (const err of errors) {
-                console.error(`✗ ${err}`);
-            }
-            process.exit(errors.length > 0 ? 1 : 0);
-            break;
-        }
-        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 });
+    case "analyze": {
+        handleAnalyze(cli, { inkStdin, isCI });
         break;
     }
-    case 'doctor': {
-        render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(Doctor, null)), { stdin: inkStdin });
+    case "workflow": {
+        await handleWorkflow(cli);
         break;
     }
-    case 'analyze': {
-        render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(AnalyzeUI, { dryRun: cli.flags.dryRun })), { stdin: inkStdin });
+    case "llms-txt": {
+        handleLlmsTxt(cli, { inkStdin, isCI });
         break;
     }
-    case 'llms-txt': {
-        render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(LlmsTxt, { projectDir: process.cwd(), dryRun: cli.flags.dryRun })), { stdin: inkStdin });
+    case "plugin": {
+        handlePlugin(cli, { inkStdin, isCI });
         break;
     }
-    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 target = cli.input[2];
-        render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(Plugin, { action: action, target: target, dryRun: cli.flags.dryRun })), { stdin: inkStdin });
+    case "skills": {
+        await handleSkillsCmd(cli, { inkStdin, isCI });
         break;
     }
-    case 'skills': {
-        const skillsAction = cli.input[1];
-        const VALID_SKILLS_ACTIONS = ['doctor', 'budget', 'score', 'benchmark'];
-        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');
-            process.exit(1);
-            break;
-        }
-        // Score and benchmark are non-interactive CLI commands
-        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 result = await scoreSkill(skillPath, cli.flags.budget);
-                if (!result) {
-                    console.error(`\u2717 Skill not found: ${skillPath}`);
-                    process.exit(1);
-                    break;
-                }
-                console.log(`\nSkill: ${result.skillName}`);
-                console.log(`  Completeness:      ${result.completeness}/100`);
-                console.log(`  Clarity:           ${result.clarity}/100`);
-                console.log(`  Testability:       ${result.testability}/100`);
-                console.log(`  Token Efficiency:  ${result.tokenEfficiency}/100`);
-                console.log(`  Overall:           ${result.overall}/100`);
-                console.log(`  Threshold:         ${result.threshold}`);
-                console.log(`  Status:            ${result.passing ? '\u2713 PASSING' : '\u2717 FAILING'}`);
-                process.exit(result.passing ? 0 : 1);
-            }
-            else {
-                const { benchmarkSkill } = await import('./commands/skills.js');
-                const result = await benchmarkSkill(skillPath);
-                if (!result) {
-                    console.error(`\u2717 Skill not found: ${skillPath}`);
-                    process.exit(1);
-                    break;
-                }
-                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}` : ''}`);
-                }
-                console.log(`\n  Pass rate: ${result.passRate}%`);
-                process.exit(result.passRate >= 50 ? 0 : 1);
-            }
-            break;
-        }
-        const skillsMode = skillsAction;
-        render(React.createElement(CIContextProvider, { isCI: isCI },
-            React.createElement(Skills, { mode: skillsMode, budget: cli.flags.budget, deep: cli.flags.deep, skillsDir: cli.flags.skillsDir || undefined })), { stdin: inkStdin });
+    case "skill": {
+        await handleSkillPublish(cli);
         break;
     }
-    case 'security': {
-        const securityAction = cli.input[1];
-        const VALID_SECURITY_ACTIONS = ['baseline', 'check', 'update'];
-        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)');
-            process.exit(1);
-            break;
-        }
-        const { runSecurity } = await import('./commands/security.js');
-        const mode = securityAction;
-        try {
-            const result = await runSecurity(mode, process.cwd(), (step) => {
-                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) {
-                process.exit(1);
-            }
-        }
-        catch {
-            process.exit(1);
-        }
+    case "security": {
+        await handleSecurity(cli);
         break;
     }
-    case 'init':
     default: {
-        const presetStack = VALID_STACKS.includes(cli.flags.stack)
-            ? cli.flags.stack
-            : undefined;
-        const presetCI = VALID_CI.includes(cli.flags.ci)
-            ? cli.flags.ci
-            : undefined;
-        const presetMemory = VALID_MEMORY.includes(cli.flags.memory)
-            ? cli.flags.memory
-            : 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 });
+        handleInitDefault(cli, { inkStdin, isCI });
         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

package/dist/lib/agent-skills.js

@@ -1,12 +1,12 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { AGENT_SKILLS_MANIFEST_FILE, PLUGIN_MANIFEST_FILE, PLUGINS_DIR } from '../constants.js';
+import path from "node:path";
+import fs from "fs-extra";
+import { AGENT_SKILLS_MANIFEST_FILE, PLUGIN_MANIFEST_FILE, PLUGINS_DIR, } from "../constants.js";
 // ── Conversion ─────────────────────────────────────────────────────────────
 /**
  * Convert a javi-forge PluginManifest to an Agent Skills spec manifest.
  */
 export function pluginToAgentSkills(manifest, source) {
-    const skills = (manifest.skills ?? []).map(s => ({
+    const skills = (manifest.skills ?? []).map((s) => ({
         name: s,
         description: `${s} skill from ${manifest.name}`,
         path: `skills/${s}`,
@@ -27,8 +27,8 @@ export function agentSkillsToPlugin(agentManifest) {
         name: agentManifest.name,
         version: agentManifest.version,
         description: agentManifest.description,
-        skills: agentManifest.skills.map(s => s.name),
-        tags: ['agent-skills-import'],
+        skills: agentManifest.skills.map((s) => s.name),
+        tags: ["agent-skills-import"],
     };
 }
 // ── File I/O ───────────────────────────────────────────────────────────────
@@ -37,15 +37,15 @@ export function agentSkillsToPlugin(agentManifest) {
  */
 export async function generateAgentSkillsManifest(pluginDir, source) {
     const manifestPath = path.join(pluginDir, PLUGIN_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) {
-        return { success: false, error: 'plugin.json not found' };
+    if (!(await fs.pathExists(manifestPath))) {
+        return { success: false, error: "plugin.json not found" };
     }
     let manifest;
     try {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     catch {
-        return { success: false, error: 'invalid plugin.json' };
+        return { success: false, error: "invalid plugin.json" };
     }
     const agentManifest = pluginToAgentSkills(manifest, source);
     const outPath = path.join(pluginDir, AGENT_SKILLS_MANIFEST_FILE);
@@ -58,7 +58,7 @@ export async function generateAgentSkillsManifest(pluginDir, source) {
  */
 export async function exportPluginAsAgentSkills(name) {
     const pluginDir = path.join(PLUGINS_DIR, name);
-    if (!await fs.pathExists(pluginDir)) {
+    if (!(await fs.pathExists(pluginDir))) {
         return { success: false, error: `plugin "${name}" is not installed` };
     }
     return generateAgentSkillsManifest(pluginDir);
@@ -70,18 +70,23 @@ export async function exportPluginAsAgentSkills(name) {
 export async function importAgentSkillsPackage(sourceDir, options = {}) {
     const { dryRun = false } = options;
     const skillsPath = path.join(sourceDir, AGENT_SKILLS_MANIFEST_FILE);
-    if (!await fs.pathExists(skillsPath)) {
-        return { success: false, error: 'skills.json not found' };
+    if (!(await fs.pathExists(skillsPath))) {
+        return { success: false, error: "skills.json not found" };
     }
     let agentManifest;
     try {
-        agentManifest = await fs.readJson(skillsPath);
+        agentManifest = (await fs.readJson(skillsPath));
     }
     catch {
-        return { success: false, error: 'invalid skills.json' };
+        return { success: false, error: "invalid skills.json" };
     }
-    if (!agentManifest.name || !agentManifest.version || !agentManifest.description) {
-        return { success: false, error: 'skills.json missing required fields (name, version, description)' };
+    if (!agentManifest.name ||
+        !agentManifest.version ||
+        !agentManifest.description) {
+        return {
+            success: false,
+            error: "skills.json missing required fields (name, version, description)",
+        };
     }
     const pluginName = agentManifest.name;
     if (dryRun) {
@@ -96,7 +101,9 @@ export async function importAgentSkillsPackage(sourceDir, options = {}) {
     await fs.copy(sourceDir, destDir);
     // Generate plugin.json from skills.json
     const pluginManifest = agentSkillsToPlugin(agentManifest);
-    await fs.writeJson(path.join(destDir, PLUGIN_MANIFEST_FILE), pluginManifest, { spaces: 2 });
+    await fs.writeJson(path.join(destDir, PLUGIN_MANIFEST_FILE), pluginManifest, {
+        spaces: 2,
+    });
     // Write install metadata
     const installedPlugin = {
         name: pluginName,
@@ -105,7 +112,149 @@ export async function importAgentSkillsPackage(sourceDir, options = {}) {
         source: `agent-skills:${sourceDir}`,
         manifest: pluginManifest,
     };
-    await fs.writeJson(path.join(destDir, '.installed.json'), installedPlugin, { spaces: 2 });
+    await fs.writeJson(path.join(destDir, ".installed.json"), installedPlugin, {
+        spaces: 2,
+    });
     return { success: true, name: pluginName };
 }
+// ── Aggregation ──────────────────────────────────────────────────────────
+/**
+ * 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 function aggregatePluginsToSkillsJson(plugins, registryName = "javi-forge-registry", registryVersion = "1.0.0") {
+    const skills = [];
+    const sources = [];
+    for (const plugin of plugins) {
+        const { manifest } = plugin;
+        if (!manifest)
+            continue;
+        sources.push({
+            plugin: manifest.name,
+            version: manifest.version,
+            ...(manifest.repository ? { repository: manifest.repository } : {}),
+        });
+        for (const skillName of manifest.skills ?? []) {
+            skills.push({
+                name: `${manifest.name}/${skillName}`,
+                description: `${skillName} skill from ${manifest.name} plugin`,
+                path: `plugins/${manifest.name}/skills/${skillName}`,
+            });
+        }
+    }
+    return {
+        name: registryName,
+        version: registryVersion,
+        description: `Aggregated skills from ${plugins.length} javi-forge plugin(s)`,
+        skills,
+        sources,
+    };
+}
+/**
+ * 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 async function generateProjectSkillsJson(projectDir, options = {}) {
+    const { dryRun = false, registryName } = options;
+    const pluginsDir = path.join(projectDir, ".javi-forge", "plugins");
+    if (!(await fs.pathExists(pluginsDir))) {
+        return {
+            success: false,
+            skillCount: 0,
+            pluginCount: 0,
+            error: "no plugins directory found",
+        };
+    }
+    const entries = await fs.readdir(pluginsDir);
+    const plugins = [];
+    for (const entry of entries) {
+        if (entry.startsWith("."))
+            continue;
+        const metaPath = path.join(pluginsDir, entry, ".installed.json");
+        if (await fs.pathExists(metaPath)) {
+            try {
+                const meta = (await fs.readJson(metaPath));
+                if (meta.name)
+                    plugins.push(meta);
+            }
+            catch {
+                /* skip corrupt entries */
+            }
+        }
+    }
+    if (plugins.length === 0) {
+        return {
+            success: false,
+            skillCount: 0,
+            pluginCount: 0,
+            error: "no installed plugins found",
+        };
+    }
+    const projectName = registryName ?? path.basename(projectDir);
+    const aggregated = aggregatePluginsToSkillsJson(plugins, projectName);
+    const outPath = path.join(projectDir, AGENT_SKILLS_MANIFEST_FILE);
+    if (!dryRun) {
+        await fs.writeJson(outPath, aggregated, { spaces: 2 });
+    }
+    return {
+        success: true,
+        path: outPath,
+        skillCount: aggregated.skills.length,
+        pluginCount: plugins.length,
+    };
+}
+/**
+ * Generate a skills.json from all globally installed plugins.
+ * Writes to the global plugins directory.
+ */
+export async function generateGlobalSkillsJson(options = {}) {
+    const { dryRun = false } = options;
+    if (!(await fs.pathExists(PLUGINS_DIR))) {
+        return {
+            success: false,
+            skillCount: 0,
+            pluginCount: 0,
+            error: "no plugins directory found",
+        };
+    }
+    const entries = await fs.readdir(PLUGINS_DIR);
+    const plugins = [];
+    for (const entry of entries) {
+        if (entry.startsWith("."))
+            continue;
+        const metaPath = path.join(PLUGINS_DIR, entry, ".installed.json");
+        if (await fs.pathExists(metaPath)) {
+            try {
+                const meta = (await fs.readJson(metaPath));
+                if (meta.name)
+                    plugins.push(meta);
+            }
+            catch {
+                /* skip corrupt entries */
+            }
+        }
+    }
+    if (plugins.length === 0) {
+        return {
+            success: false,
+            skillCount: 0,
+            pluginCount: 0,
+            error: "no installed plugins found",
+        };
+    }
+    const aggregated = aggregatePluginsToSkillsJson(plugins);
+    const outPath = path.join(PLUGINS_DIR, AGENT_SKILLS_MANIFEST_FILE);
+    if (!dryRun) {
+        await fs.writeJson(outPath, aggregated, { spaces: 2 });
+    }
+    return {
+        success: true,
+        path: outPath,
+        skillCount: aggregated.skills.length,
+        pluginCount: plugins.length,
+    };
+}
 //# sourceMappingURL=agent-skills.js.map