javi-forge 1.6.0 → 1.6.1

package/dist/lib/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { PluginValidationResult, InstalledPlugin, PluginRegistryEntry, PluginSyncResult } from '../types/index.js';
+import type { InstalledPlugin, PluginRegistryEntry, PluginSyncResult, PluginValidationResult } from "../types/index.js";
 /**
  * Validate a plugin directory structure and manifest.
  */
@@ -37,8 +37,14 @@ export declare function searchRegistry(query?: string): Promise<PluginRegistryEn
  */
 export declare function detectProjectPlugins(projectDir: string): Promise<string[]>;
 /**
- * Sync detected plugins into the project manifest.
- * Returns a report of added, removed, and unchanged plugins.
+ * Detect installed plugins with full metadata (including manifest).
+ * Used by auto-wiring to read plugin capabilities.
+ */
+export declare function detectProjectPluginsFull(projectDir: string): Promise<InstalledPlugin[]>;
+/**
+ * Sync detected plugins into the project manifest and auto-wire
+ * their capabilities into CLAUDE.md and .claude/settings.json.
+ * Returns a report of added, removed, unchanged, wired, and unwired plugins.
  */
 export declare function syncPlugins(projectDir: string, options?: {
     dryRun?: boolean;

package/dist/lib/plugin.js

@@ -1,9 +1,10 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { PLUGINS_DIR, PLUGIN_MANIFEST_FILE, PLUGIN_ASSET_DIRS, PLUGIN_REGISTRY_URL } from '../constants.js';
-import { generateAgentSkillsManifest } from './agent-skills.js';
+import { execFile } from "child_process";
+import fs from "fs-extra";
+import path from "path";
+import { promisify } from "util";
+import { PLUGIN_ASSET_DIRS, PLUGIN_MANIFEST_FILE, PLUGIN_REGISTRY_URL, PLUGINS_DIR, } from "../constants.js";
+import { generateAgentSkillsManifest } from "./agent-skills.js";
+import { autoWirePlugins } from "./auto-wire.js";
 const execFileAsync = promisify(execFile);
 const KEBAB_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 const SEMVER_RE = /^\d+\.\d+\.\d+$/;
@@ -15,49 +16,60 @@ export async function validatePlugin(pluginDir) {
     const errors = [];
     // Check plugin.json exists
     const manifestPath = path.join(pluginDir, PLUGIN_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) {
+    if (!(await fs.pathExists(manifestPath))) {
         return {
             valid: false,
-            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'plugin.json not found' }],
+            errors: [
+                { path: PLUGIN_MANIFEST_FILE, message: "plugin.json not found" },
+            ],
             manifest: null,
         };
     }
     // Parse manifest
     let manifest;
     try {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     catch {
         return {
             valid: false,
-            errors: [{ path: PLUGIN_MANIFEST_FILE, message: 'invalid JSON' }],
+            errors: [{ path: PLUGIN_MANIFEST_FILE, message: "invalid JSON" }],
             manifest: null,
         };
     }
     // Validate required fields
-    if (typeof manifest.name !== 'string' || !manifest.name) {
-        errors.push({ path: 'name', message: 'name is required' });
+    if (typeof manifest.name !== "string" || !manifest.name) {
+        errors.push({ path: "name", message: "name is required" });
     }
     else if (!KEBAB_RE.test(manifest.name)) {
-        errors.push({ path: 'name', message: 'name must be kebab-case' });
+        errors.push({ path: "name", message: "name must be kebab-case" });
     }
     else if (manifest.name.length < 2 || manifest.name.length > 60) {
-        errors.push({ path: 'name', message: 'name must be 2-60 characters' });
+        errors.push({ path: "name", message: "name must be 2-60 characters" });
     }
-    if (typeof manifest.version !== 'string' || !manifest.version) {
-        errors.push({ path: 'version', message: 'version is required' });
+    if (typeof manifest.version !== "string" || !manifest.version) {
+        errors.push({ path: "version", message: "version is required" });
     }
     else if (!SEMVER_RE.test(manifest.version)) {
-        errors.push({ path: 'version', message: 'version must be semver (e.g. 1.0.0)' });
+        errors.push({
+            path: "version",
+            message: "version must be semver (e.g. 1.0.0)",
+        });
     }
-    if (typeof manifest.description !== 'string' || !manifest.description) {
-        errors.push({ path: 'description', message: 'description is required' });
+    if (typeof manifest.description !== "string" || !manifest.description) {
+        errors.push({ path: "description", message: "description is required" });
     }
     else if (manifest.description.length < 10) {
-        errors.push({ path: 'description', message: 'description must be at least 10 characters' });
+        errors.push({
+            path: "description",
+            message: "description must be at least 10 characters",
+        });
     }
     else if (manifest.description.length > 200) {
-        errors.push({ path: 'description', message: 'description must be at most 200 characters' });
+        errors.push({
+            path: "description",
+            message: "description must be at most 200 characters",
+        });
     }
     // Validate asset directories actually exist when declared
     for (const assetType of PLUGIN_ASSET_DIRS) {
@@ -65,26 +77,36 @@ export async function validatePlugin(pluginDir) {
         if (!Array.isArray(declared) || declared.length === 0)
             continue;
         const assetDir = path.join(pluginDir, assetType);
-        if (!await fs.pathExists(assetDir)) {
-            errors.push({ path: assetType, message: `declared ${assetType}/ directory not found` });
+        if (!(await fs.pathExists(assetDir))) {
+            errors.push({
+                path: assetType,
+                message: `declared ${assetType}/ directory not found`,
+            });
             continue;
         }
         // Check each declared asset exists
         for (const entry of declared) {
             const entryPath = path.join(assetDir, entry);
-            if (!await fs.pathExists(entryPath)) {
-                errors.push({ path: `${assetType}/${entry}`, message: `declared entry not found` });
+            if (!(await fs.pathExists(entryPath))) {
+                errors.push({
+                    path: `${assetType}/${entry}`,
+                    message: `declared entry not found`,
+                });
             }
         }
     }
     // Validate tags
     if (manifest.tags && !Array.isArray(manifest.tags)) {
-        errors.push({ path: 'tags', message: 'tags must be an array' });
+        errors.push({ path: "tags", message: "tags must be an array" });
     }
     else if (manifest.tags && manifest.tags.length > 10) {
-        errors.push({ path: 'tags', message: 'max 10 tags allowed' });
+        errors.push({ path: "tags", message: "max 10 tags allowed" });
     }
-    return { valid: errors.length === 0, errors, manifest: errors.length === 0 ? manifest : manifest };
+    return {
+        valid: errors.length === 0,
+        errors,
+        manifest: errors.length === 0 ? manifest : manifest,
+    };
 }
 // ── Installation ────────────────────────────────────────────────────────────
 /**
@@ -96,23 +118,36 @@ export async function installPlugin(source, options = {}) {
     // Normalize source to a git URL
     const gitUrl = normalizeGitUrl(source);
     if (!gitUrl) {
-        return { success: false, error: `invalid source: ${source}. Use org/repo or a GitHub URL` };
+        return {
+            success: false,
+            error: `invalid source: ${source}. Use org/repo or a GitHub URL`,
+        };
     }
     // Clone to temp
-    const tmpDir = path.join(PLUGINS_DIR, '.tmp', `install-${Date.now()}`);
+    const tmpDir = path.join(PLUGINS_DIR, ".tmp", `install-${Date.now()}`);
     try {
         if (!dryRun) {
             await fs.ensureDir(tmpDir);
-            await execFileAsync('git', ['clone', '--depth', '1', gitUrl, tmpDir], {
+            await execFileAsync("git", ["clone", "--depth", "1", gitUrl, tmpDir], {
                 timeout: 60_000,
             });
         }
         // Validate
         const validation = dryRun
-            ? { valid: true, errors: [], manifest: { name: source.split('/').pop() ?? 'unknown', version: '0.0.0', description: 'dry-run placeholder' } }
+            ? {
+                valid: true,
+                errors: [],
+                manifest: {
+                    name: source.split("/").pop() ?? "unknown",
+                    version: "0.0.0",
+                    description: "dry-run placeholder",
+                },
+            }
             : await validatePlugin(tmpDir);
         if (!validation.valid || !validation.manifest) {
-            const msgs = validation.errors.map(e => `  ${e.path}: ${e.message}`).join('\n');
+            const msgs = validation.errors
+                .map((e) => `  ${e.path}: ${e.message}`)
+                .join("\n");
             return { success: false, error: `validation failed:\n${msgs}` };
         }
         const pluginName = validation.manifest.name;
@@ -131,7 +166,7 @@ export async function installPlugin(source, options = {}) {
                 source,
                 manifest: validation.manifest,
             };
-            await fs.writeJson(path.join(destDir, '.installed.json'), installedPlugin, { spaces: 2 });
+            await fs.writeJson(path.join(destDir, ".installed.json"), installedPlugin, { spaces: 2 });
             // Generate Agent Skills spec manifest for cross-agent compatibility
             await generateAgentSkillsManifest(destDir, source).catch(() => { });
         }
@@ -143,7 +178,7 @@ export async function installPlugin(source, options = {}) {
     }
     finally {
         // Clean up tmp if it still exists (error path)
-        if (!dryRun && await fs.pathExists(tmpDir)) {
+        if (!dryRun && (await fs.pathExists(tmpDir))) {
             await fs.remove(tmpDir).catch(() => { });
         }
     }
@@ -153,7 +188,7 @@ export async function installPlugin(source, options = {}) {
  */
 export async function removePlugin(name, options = {}) {
     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` };
     }
     if (!options.dryRun) {
@@ -166,20 +201,22 @@ export async function removePlugin(name, options = {}) {
  * List all installed plugins.
  */
 export async function listInstalledPlugins() {
-    if (!await fs.pathExists(PLUGINS_DIR))
+    if (!(await fs.pathExists(PLUGINS_DIR)))
         return [];
     const entries = await fs.readdir(PLUGINS_DIR);
     const plugins = [];
     for (const entry of entries) {
-        if (entry.startsWith('.'))
+        if (entry.startsWith("."))
             continue;
-        const metaPath = path.join(PLUGINS_DIR, entry, '.installed.json');
+        const metaPath = path.join(PLUGINS_DIR, entry, ".installed.json");
         if (await fs.pathExists(metaPath)) {
             try {
-                const meta = await fs.readJson(metaPath);
+                const meta = (await fs.readJson(metaPath));
                 plugins.push(meta);
             }
-            catch { /* skip corrupt entries */ }
+            catch {
+                /* skip corrupt entries */
+            }
         }
     }
     return plugins;
@@ -193,13 +230,13 @@ export async function searchRegistry(query) {
         if (!response.ok) {
             return [];
         }
-        const registry = await response.json();
+        const registry = (await response.json());
         let plugins = registry.plugins ?? [];
         if (query) {
             const q = query.toLowerCase();
-            plugins = plugins.filter(p => p.id.toLowerCase().includes(q) ||
+            plugins = plugins.filter((p) => p.id.toLowerCase().includes(q) ||
                 p.description.toLowerCase().includes(q) ||
-                p.tags.some(t => t.toLowerCase().includes(q)));
+                p.tags.some((t) => t.toLowerCase().includes(q)));
         }
         return plugins;
     }
@@ -213,47 +250,59 @@ export async function searchRegistry(query) {
  * Returns an array of plugin names (sorted alphabetically).
  */
 export async function detectProjectPlugins(projectDir) {
-    const pluginsDir = path.join(projectDir, '.javi-forge', 'plugins');
-    if (!await fs.pathExists(pluginsDir))
+    const full = await detectProjectPluginsFull(projectDir);
+    return full.map((p) => p.name).sort();
+}
+/**
+ * Detect installed plugins with full metadata (including manifest).
+ * Used by auto-wiring to read plugin capabilities.
+ */
+export async function detectProjectPluginsFull(projectDir) {
+    const pluginsDir = path.join(projectDir, ".javi-forge", "plugins");
+    if (!(await fs.pathExists(pluginsDir)))
         return [];
     const entries = await fs.readdir(pluginsDir);
     const plugins = [];
     for (const entry of entries) {
-        if (entry.startsWith('.'))
+        if (entry.startsWith("."))
             continue;
-        const metaPath = path.join(pluginsDir, entry, '.installed.json');
+        const metaPath = path.join(pluginsDir, entry, ".installed.json");
         if (await fs.pathExists(metaPath)) {
             try {
-                const meta = await fs.readJson(metaPath);
+                const meta = (await fs.readJson(metaPath));
                 if (meta.name) {
-                    plugins.push(meta.name);
+                    plugins.push(meta);
                 }
             }
-            catch { /* skip corrupt entries */ }
+            catch {
+                /* skip corrupt entries */
+            }
         }
     }
-    return plugins.sort();
+    return plugins.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
- * Sync detected plugins into the project manifest.
- * Returns a report of added, removed, and unchanged plugins.
+ * Sync detected plugins into the project manifest and auto-wire
+ * their capabilities into CLAUDE.md and .claude/settings.json.
+ * Returns a report of added, removed, unchanged, wired, and unwired plugins.
  */
 export async function syncPlugins(projectDir, options = {}) {
     const { dryRun = false } = options;
-    const detected = await detectProjectPlugins(projectDir);
-    const manifestPath = path.join(projectDir, '.javi-forge', 'manifest.json');
+    const detectedFull = await detectProjectPluginsFull(projectDir);
+    const detected = detectedFull.map((p) => p.name).sort();
+    const manifestPath = path.join(projectDir, ".javi-forge", "manifest.json");
     let manifest;
     if (await fs.pathExists(manifestPath)) {
-        manifest = await fs.readJson(manifestPath);
+        manifest = (await fs.readJson(manifestPath));
     }
     else {
         // No manifest yet — treat current plugins as empty
         manifest = {
-            version: '0.1.0',
+            version: "0.1.0",
             projectName: path.basename(projectDir),
-            stack: 'node',
-            ciProvider: 'github',
-            memory: 'none',
+            stack: "node",
+            ciProvider: "github",
+            memory: "none",
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             modules: [],
@@ -261,16 +310,26 @@ export async function syncPlugins(projectDir, options = {}) {
     }
     const previous = new Set(manifest.plugins ?? []);
     const current = new Set(detected);
-    const added = detected.filter(p => !previous.has(p));
-    const removed = [...previous].filter(p => !current.has(p));
-    const unchanged = detected.filter(p => previous.has(p));
+    const added = detected.filter((p) => !previous.has(p));
+    const removed = [...previous].filter((p) => !current.has(p));
+    const unchanged = detected.filter((p) => previous.has(p));
     if (!dryRun && (added.length > 0 || removed.length > 0)) {
         manifest.plugins = detected;
         manifest.updatedAt = new Date().toISOString();
         await fs.ensureDir(path.dirname(manifestPath));
         await fs.writeJson(manifestPath, manifest, { spaces: 2 });
     }
-    return { added, removed, unchanged };
+    // ── Auto-wire plugin capabilities ──────────────────────────────────
+    const wireResult = await autoWirePlugins(projectDir, detectedFull, {
+        dryRun,
+    });
+    return {
+        added,
+        removed,
+        unchanged,
+        wired: wireResult.wired,
+        unwired: wireResult.unwired,
+    };
 }
 // ── Helpers ─────────────────────────────────────────────────────────────────
 /**
@@ -279,15 +338,15 @@ export async function syncPlugins(projectDir, options = {}) {
  */
 export function normalizeGitUrl(source) {
     // Already a full URL
-    if (source.startsWith('https://github.com/')) {
-        return source.endsWith('.git') ? source : `${source}.git`;
+    if (source.startsWith("https://github.com/")) {
+        return source.endsWith(".git") ? source : `${source}.git`;
     }
     // github.com/org/repo
-    if (source.startsWith('github.com/')) {
+    if (source.startsWith("github.com/")) {
         return `https://${source}.git`;
     }
     // org/repo shorthand
-    const parts = source.split('/');
+    const parts = source.split("/");
     if (parts.length === 2 && parts[0] && parts[1]) {
         return `https://github.com/${parts[0]}/${parts[1]}.git`;
     }

package/dist/lib/skill-publish.d.ts

@@ -0,0 +1,40 @@
+import type { PluginManifest } from "../types/index.js";
+export interface SkillPublishResult {
+    success: boolean;
+    /** Path to the generated plugin.json */
+    pluginJsonPath?: string;
+    /** The generated manifest */
+    manifest?: PluginManifest;
+    error?: string;
+}
+export interface SkillPublishOptions {
+    /** Path to the skill directory (contains SKILL.md) */
+    skillDir: string;
+    /** Author name (optional, falls back to frontmatter or git user) */
+    author?: string;
+    /** Repository URL (optional) */
+    repository?: string;
+    /** Tags for marketplace discovery */
+    tags?: string[];
+    /** If true, skip writing files */
+    dryRun?: boolean;
+}
+/**
+ * Package a skill directory for marketplace distribution.
+ *
+ * Reads the SKILL.md, extracts metadata from frontmatter, and generates
+ * a plugin.json compatible with both `javi-forge plugin install` and
+ * `claude plugin install` (Anthropic's plugin format).
+ *
+ * Expected input structure:
+ *   skill-name/
+ *     SKILL.md
+ *     (optional other files)
+ *
+ * Output:
+ *   skill-name/
+ *     SKILL.md
+ *     plugin.json   ← generated
+ */
+export declare function publishSkill(options: SkillPublishOptions): Promise<SkillPublishResult>;
+//# sourceMappingURL=skill-publish.d.ts.map

package/dist/lib/skill-publish.js

@@ -0,0 +1,146 @@
+import fs from "fs-extra";
+import path from "path";
+import { PLUGIN_MANIFEST_FILE } from "../constants.js";
+import { parseFrontmatter } from "./frontmatter.js";
+// ── Core ───────────────────────────────────────────────────────────────────
+/**
+ * Package a skill directory for marketplace distribution.
+ *
+ * Reads the SKILL.md, extracts metadata from frontmatter, and generates
+ * a plugin.json compatible with both `javi-forge plugin install` and
+ * `claude plugin install` (Anthropic's plugin format).
+ *
+ * Expected input structure:
+ *   skill-name/
+ *     SKILL.md
+ *     (optional other files)
+ *
+ * Output:
+ *   skill-name/
+ *     SKILL.md
+ *     plugin.json   ← generated
+ */
+export async function publishSkill(options) {
+    const { skillDir, author, repository, tags = [], dryRun = false } = options;
+    // Validate skill directory
+    const skillMdPath = path.join(skillDir, "SKILL.md");
+    if (!(await fs.pathExists(skillMdPath))) {
+        return { success: false, error: `SKILL.md not found in ${skillDir}` };
+    }
+    // Read and parse SKILL.md
+    let raw;
+    try {
+        raw = await fs.readFile(skillMdPath, "utf-8");
+    }
+    catch {
+        return { success: false, error: "Failed to read SKILL.md" };
+    }
+    const parsed = parseFrontmatter(raw);
+    const frontmatter = parsed?.data ?? {};
+    // Extract metadata
+    const name = frontmatter["name"] ?? path.basename(skillDir);
+    const version = frontmatter["version"] ?? "1.0.0";
+    const description = frontmatter["description"] ?? `${name} AI skill`;
+    // Validate name format (kebab-case)
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+        return {
+            success: false,
+            error: `Skill name "${name}" must be kebab-case (e.g., "react-19", "tailwind-4")`,
+        };
+    }
+    // Validate description length
+    if (description.length < 10) {
+        return {
+            success: false,
+            error: "Description must be at least 10 characters",
+        };
+    }
+    // Build plugin.json manifest
+    const manifest = {
+        name,
+        version,
+        description: description.length > 200
+            ? description.slice(0, 197) + "..."
+            : description,
+        skills: [name],
+        tags: tags.length > 0 ? tags : extractTagsFromDescription(description),
+        ...(author ? { author } : {}),
+        ...(repository ? { repository } : {}),
+    };
+    if (!dryRun) {
+        const pluginJsonPath = path.join(skillDir, PLUGIN_MANIFEST_FILE);
+        await fs.writeJson(pluginJsonPath, manifest, { spaces: 2 });
+        // Also create a skills/ subdirectory structure for plugin compatibility
+        const skillsSubdir = path.join(skillDir, "skills", name);
+        if (!(await fs.pathExists(skillsSubdir))) {
+            await fs.ensureDir(skillsSubdir);
+            // Symlink or copy SKILL.md into skills/name/
+            const targetSkillMd = path.join(skillsSubdir, "SKILL.md");
+            if (!(await fs.pathExists(targetSkillMd))) {
+                await fs.copy(skillMdPath, targetSkillMd);
+            }
+        }
+        return { success: true, pluginJsonPath, manifest };
+    }
+    return {
+        success: true,
+        pluginJsonPath: path.join(skillDir, PLUGIN_MANIFEST_FILE),
+        manifest,
+    };
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+/**
+ * Extract reasonable tags from a skill description.
+ * Looks for common tech keywords.
+ */
+function extractTagsFromDescription(description) {
+    const keywords = [
+        "react",
+        "next",
+        "nextjs",
+        "angular",
+        "vue",
+        "svelte",
+        "typescript",
+        "javascript",
+        "python",
+        "go",
+        "rust",
+        "java",
+        "elixir",
+        "tailwind",
+        "css",
+        "styling",
+        "testing",
+        "test",
+        "e2e",
+        "unit",
+        "api",
+        "rest",
+        "graphql",
+        "ai",
+        "llm",
+        "ml",
+        "agent",
+        "security",
+        "auth",
+        "database",
+        "sql",
+        "nosql",
+        "docker",
+        "kubernetes",
+        "devops",
+        "ci",
+        "cd",
+        "state",
+        "management",
+        "store",
+        "validation",
+        "schema",
+        "zod",
+    ];
+    const lower = description.toLowerCase();
+    const found = keywords.filter((kw) => lower.includes(kw));
+    return found.slice(0, 10); // Max 10 tags per plugin spec
+}
+//# sourceMappingURL=skill-publish.js.map

package/dist/lib/stack-detector.d.ts

@@ -0,0 +1,38 @@
+import type { Stack } from "../types/index.js";
+/**
+ * Maps detected project signals to recommended AI skills.
+ * Each key is a detection signal (file/dependency/pattern),
+ * and the value is the list of skills it implies.
+ */
+export declare const SIGNAL_SKILL_MAP: Record<string, string[]>;
+/**
+ * Docker-related files that indicate a containerized project.
+ * Used by the init command to suggest Docker zero-downtime deploy scaffolding.
+ */
+export declare const DOCKER_FILES: string[];
+/**
+ * Detect whether the project uses Docker (Dockerfile or compose file present).
+ */
+export declare function detectDockerPresence(projectDir: string): Promise<boolean>;
+export interface StackDetectionResult {
+    /** Primary stack type (node, python, etc.) */
+    stack: Stack | null;
+    /** All detected signals with their source */
+    signals: DetectedSignal[];
+    /** De-duplicated list of recommended skill names */
+    recommendedSkills: string[];
+}
+export interface DetectedSignal {
+    /** What was detected (e.g., "react", "tailwindcss", "tsconfig.json") */
+    signal: string;
+    /** Where it was found (e.g., "package.json dependencies", "file exists") */
+    source: string;
+    /** Skills this signal maps to */
+    skills: string[];
+}
+/**
+ * Scan a project directory and detect its tech stack + recommended skills.
+ * Reads package.json deps, pyproject.toml, and well-known config files.
+ */
+export declare function detectProjectStack(projectDir: string): Promise<StackDetectionResult>;
+//# sourceMappingURL=stack-detector.d.ts.map