javi-forge 1.5.0 → 1.6.1

package/dist/index.js

@@ -1,20 +1,23 @@
 #!/usr/bin/env node
-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 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
@@ -23,13 +26,35 @@ const cli = meow(`
   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)
+    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
     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 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
+    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
@@ -40,7 +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
 
@@ -63,6 +94,7 @@ const cli = meow(`
     $ 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
@@ -74,44 +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: "" },
+        // 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 'ci': {
+    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 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 <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": {
         // 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}`);
@@ -119,39 +214,290 @@ 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'];
-        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": {
+        const skillsAction = cli.input[1];
+        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|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") {
+            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(`  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"}`);
+                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 });
+        break;
+    }
+    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", "allowlist"];
+        if (!securityAction || !VALID_SECURITY_ACTIONS.includes(securityAction)) {
+            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 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) => {
+                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}`);
+            }, checkOptions);
+            if (jsonOutput && result) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            if (mode === "check" && result && result.filteredRegressions.length > 0) {
+                process.exit(1);
+            }
+        }
+        catch {
+            process.exit(1);
+        }
         break;
     }
-    case 'init':
+    case "init":
     default: {
         const presetStack = VALID_STACKS.includes(cli.flags.stack)
             ? cli.flags.stack
@@ -164,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

@@ -0,0 +1,73 @@
+import type { AgentSkillsManifest, AggregatedSkillsManifest, InstalledPlugin, PluginManifest } from "../types/index.js";
+/**
+ * Convert a javi-forge PluginManifest to an Agent Skills spec manifest.
+ */
+export declare function pluginToAgentSkills(manifest: PluginManifest, source?: string): AgentSkillsManifest;
+/**
+ * Convert an Agent Skills spec manifest to a javi-forge PluginManifest.
+ */
+export declare function agentSkillsToPlugin(agentManifest: AgentSkillsManifest): PluginManifest;
+/**
+ * Generate a skills.json file in the given plugin directory from its plugin.json.
+ */
+export declare function generateAgentSkillsManifest(pluginDir: string, source?: string): Promise<{
+    success: boolean;
+    path?: string;
+    error?: string;
+}>;
+/**
+ * Export an installed plugin to Agent Skills format.
+ * Looks up the plugin by name in the global plugins directory.
+ */
+export declare function exportPluginAsAgentSkills(name: string): Promise<{
+    success: boolean;
+    path?: string;
+    error?: string;
+}>;
+/**
+ * Import an Agent Skills spec package from a directory.
+ * Reads skills.json, converts to plugin.json, copies to plugins dir.
+ */
+export declare function importAgentSkillsPackage(sourceDir: string, options?: {
+    dryRun?: boolean;
+}): Promise<{
+    success: boolean;
+    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