javi-forge 1.6.0 → 1.7.0

package/dist/lib/frontmatter.js

@@ -1,20 +1,20 @@
-import YAML from 'yaml';
+import YAML from "yaml";
 /**
  * Extract YAML frontmatter from a markdown string.
  * Frontmatter is delimited by --- at the start of the file.
  */
 export function parseFrontmatter(raw) {
     const trimmed = raw.trimStart();
-    if (!trimmed.startsWith('---'))
+    if (!trimmed.startsWith("---"))
         return null;
-    const endIdx = trimmed.indexOf('---', 3);
+    const endIdx = trimmed.indexOf("---", 3);
     if (endIdx === -1)
         return null;
     const yamlBlock = trimmed.slice(3, endIdx).trim();
     const content = trimmed.slice(endIdx + 3).trim();
     try {
         const data = YAML.parse(yamlBlock);
-        if (typeof data !== 'object' || data === null)
+        if (typeof data !== "object" || data === null)
             return null;
         return { data, content };
     }
@@ -29,30 +29,44 @@ const KEBAB_CASE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 export function validateFrontmatter(frontmatter, type) {
     const errors = [];
     // name: required, kebab-case, 2-60 chars
-    const name = frontmatter['name'];
-    if (typeof name !== 'string' || !name) {
-        errors.push({ field: 'name', message: 'name is required and must be a string' });
+    const name = frontmatter.name;
+    if (typeof name !== "string" || !name) {
+        errors.push({
+            field: "name",
+            message: "name is required and must be a string",
+        });
     }
     else {
         if (name.length < 2 || name.length > 60) {
-            errors.push({ field: 'name', message: 'name must be 2-60 characters' });
+            errors.push({ field: "name", message: "name must be 2-60 characters" });
         }
         if (!KEBAB_CASE_RE.test(name)) {
-            errors.push({ field: 'name', message: 'name must be kebab-case (e.g. my-skill-name)' });
+            errors.push({
+                field: "name",
+                message: "name must be kebab-case (e.g. my-skill-name)",
+            });
         }
     }
     // description: required, non-empty, min 10 chars
-    const desc = frontmatter['description'];
-    if (typeof desc !== 'string' || !desc) {
-        errors.push({ field: 'description', message: 'description is required and must be a string' });
+    const desc = frontmatter.description;
+    if (typeof desc !== "string" || !desc) {
+        errors.push({
+            field: "description",
+            message: "description is required and must be a string",
+        });
     }
     else if (desc.length < 10) {
-        errors.push({ field: 'description', message: 'description must be at least 10 characters' });
+        errors.push({
+            field: "description",
+            message: "description must be at least 10 characters",
+        });
     }
     // skill-specific: description should include "Trigger:" hint
-    if (type === 'skill' && typeof desc === 'string' && !desc.includes('Trigger:')) {
+    if (type === "skill" &&
+        typeof desc === "string" &&
+        !desc.includes("Trigger:")) {
         errors.push({
-            field: 'description',
+            field: "description",
             message: 'skill description should include a "Trigger:" hint for auto-invoke',
         });
     }

package/dist/lib/harness-audit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Harness audit — scores how well-configured the AI agent development
+ * environment is (hooks, skills, memory, configs). Detects which AI
+ * agent harness is installed and generates appropriate config.
+ */
+export type Harness = "claude" | "cursor" | "codex" | "copilot" | "windsurf" | "none";
+export interface HarnessDetection {
+    harness: Harness;
+    configDir: string | null;
+    version: string | null;
+}
+export interface AuditCategory {
+    name: string;
+    score: number;
+    maxScore: number;
+    checks: AuditCheck[];
+}
+export interface AuditCheck {
+    id: string;
+    label: string;
+    passed: boolean;
+    points: number;
+    detail?: string;
+}
+export interface HarnessAuditResult {
+    harness: Harness;
+    totalScore: number;
+    maxScore: number;
+    grade: string;
+    categories: AuditCategory[];
+}
+export declare function detectHarness(projectDir: string): HarnessDetection;
+export declare function detectAllHarnesses(projectDir: string): HarnessDetection[];
+export declare function runHarnessAudit(projectDir: string): HarnessAuditResult;
+//# sourceMappingURL=harness-audit.d.ts.map

package/dist/lib/harness-audit.js

@@ -0,0 +1,277 @@
+/**
+ * Harness audit — scores how well-configured the AI agent development
+ * environment is (hooks, skills, memory, configs). Detects which AI
+ * agent harness is installed and generates appropriate config.
+ */
+import path from "node:path";
+import fs from "fs-extra";
+// ── Harness Detection ──
+const HARNESS_SIGNATURES = [
+    {
+        harness: "claude",
+        markers: [".claude", "CLAUDE.md"],
+        configDir: ".claude",
+    },
+    {
+        harness: "cursor",
+        markers: [".cursor", ".cursorrules"],
+        configDir: ".cursor",
+    },
+    { harness: "codex", markers: [".codex", "AGENTS.md"], configDir: ".codex" },
+    {
+        harness: "copilot",
+        markers: [".github/copilot-instructions.md"],
+        configDir: ".github",
+    },
+    { harness: "windsurf", markers: [".windsurfrules"], configDir: "." },
+];
+export function detectHarness(projectDir) {
+    for (const sig of HARNESS_SIGNATURES) {
+        for (const marker of sig.markers) {
+            const fullPath = path.join(projectDir, marker);
+            if (fs.existsSync(fullPath)) {
+                return {
+                    harness: sig.harness,
+                    configDir: path.join(projectDir, sig.configDir),
+                    version: null,
+                };
+            }
+        }
+    }
+    // Check home directory for global installs
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (home && fs.existsSync(path.join(home, ".claude"))) {
+        return {
+            harness: "claude",
+            configDir: path.join(home, ".claude"),
+            version: null,
+        };
+    }
+    return { harness: "none", configDir: null, version: null };
+}
+export function detectAllHarnesses(projectDir) {
+    const found = [];
+    for (const sig of HARNESS_SIGNATURES) {
+        for (const marker of sig.markers) {
+            if (fs.existsSync(path.join(projectDir, marker))) {
+                found.push({
+                    harness: sig.harness,
+                    configDir: path.join(projectDir, sig.configDir),
+                    version: null,
+                });
+                break; // one detection per harness
+            }
+        }
+    }
+    return found;
+}
+// ── Audit Checks ──
+function checkFileExists(dir, relativePath) {
+    return fs.existsSync(path.join(dir, relativePath));
+}
+function checkDirHasFiles(dir, relativePath) {
+    const full = path.join(dir, relativePath);
+    if (!fs.existsSync(full))
+        return false;
+    try {
+        const entries = fs.readdirSync(full);
+        return entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function auditClaude(projectDir, configDir) {
+    const categories = [];
+    // Config category
+    const configChecks = [
+        {
+            id: "claude-md",
+            label: "CLAUDE.md exists",
+            passed: checkFileExists(projectDir, "CLAUDE.md") ||
+                checkFileExists(configDir, "CLAUDE.md"),
+            points: 15,
+        },
+        {
+            id: "settings",
+            label: "settings.json configured",
+            passed: checkFileExists(configDir, "settings.json") ||
+                checkFileExists(configDir, "settings.local.json"),
+            points: 10,
+        },
+        {
+            id: "project-config",
+            label: "Project-level config exists",
+            passed: checkDirHasFiles(configDir, "projects"),
+            points: 5,
+        },
+    ];
+    // Skills category
+    const skillChecks = [
+        {
+            id: "skills-dir",
+            label: "Skills directory exists",
+            passed: checkDirHasFiles(configDir, "skills"),
+            points: 15,
+        },
+        {
+            id: "skills-count",
+            label: "At least 5 skills installed",
+            passed: countSubdirs(path.join(configDir, "skills")) >= 5,
+            points: 10,
+        },
+        {
+            id: "shared-conventions",
+            label: "Shared conventions configured",
+            passed: checkDirHasFiles(configDir, "skills/_shared"),
+            points: 5,
+        },
+    ];
+    // Hooks category
+    const hookChecks = [
+        {
+            id: "hooks-configured",
+            label: "Hooks configured in settings",
+            passed: hasHooksInSettings(configDir),
+            points: 15,
+        },
+        {
+            id: "pre-commit-hook",
+            label: "Pre-commit or CI hook exists",
+            passed: checkFileExists(projectDir, ".husky/pre-commit") ||
+                checkFileExists(projectDir, ".git/hooks/pre-commit"),
+            points: 5,
+        },
+    ];
+    // Memory category
+    const memoryChecks = [
+        {
+            id: "memory-dir",
+            label: "Memory/projects directory exists",
+            passed: checkDirHasFiles(configDir, "projects"),
+            points: 10,
+        },
+        {
+            id: "memory-md",
+            label: "MEMORY.md exists in projects",
+            passed: hasMemoryMd(configDir),
+            points: 10,
+        },
+    ];
+    categories.push(buildCategory("Configuration", configChecks));
+    categories.push(buildCategory("Skills", skillChecks));
+    categories.push(buildCategory("Hooks", hookChecks));
+    categories.push(buildCategory("Memory", memoryChecks));
+    return categories;
+}
+function auditGeneric(projectDir) {
+    const checks = [
+        {
+            id: "has-config",
+            label: "AI agent config file exists",
+            passed: HARNESS_SIGNATURES.some((sig) => sig.markers.some((m) => checkFileExists(projectDir, m))),
+            points: 30,
+        },
+        {
+            id: "has-gitignore",
+            label: ".gitignore excludes agent artifacts",
+            passed: gitignoreHasAgent(projectDir),
+            points: 10,
+        },
+    ];
+    return [buildCategory("Basic Setup", checks)];
+}
+// ── Helpers ──
+function countSubdirs(dir) {
+    if (!fs.existsSync(dir))
+        return 0;
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function hasHooksInSettings(configDir) {
+    const settingsPath = path.join(configDir, "settings.json");
+    if (!fs.existsSync(settingsPath))
+        return false;
+    try {
+        const content = fs.readFileSync(settingsPath, "utf-8");
+        return content.includes("hooks") || content.includes("hook");
+    }
+    catch {
+        return false;
+    }
+}
+function hasMemoryMd(configDir) {
+    const projectsDir = path.join(configDir, "projects");
+    if (!fs.existsSync(projectsDir))
+        return false;
+    try {
+        const dirs = fs.readdirSync(projectsDir, { withFileTypes: true });
+        return dirs.some((d) => {
+            if (!d.isDirectory())
+                return false;
+            const memDir = path.join(projectsDir, d.name, "memory");
+            return (fs.existsSync(memDir) && fs.existsSync(path.join(memDir, "MEMORY.md")));
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function gitignoreHasAgent(projectDir) {
+    const giPath = path.join(projectDir, ".gitignore");
+    if (!fs.existsSync(giPath))
+        return false;
+    try {
+        const content = fs.readFileSync(giPath, "utf-8");
+        return (content.includes(".claude") ||
+            content.includes(".cursor") ||
+            content.includes(".codex"));
+    }
+    catch {
+        return false;
+    }
+}
+function buildCategory(name, checks) {
+    const score = checks
+        .filter((c) => c.passed)
+        .reduce((sum, c) => sum + c.points, 0);
+    const maxScore = checks.reduce((sum, c) => sum + c.points, 0);
+    return { name, score, maxScore, checks };
+}
+function computeGrade(score, max) {
+    if (max === 0)
+        return "F";
+    const pct = (score / max) * 100;
+    if (pct >= 90)
+        return "A";
+    if (pct >= 75)
+        return "B";
+    if (pct >= 60)
+        return "C";
+    if (pct >= 40)
+        return "D";
+    return "F";
+}
+// ── Main ──
+export function runHarnessAudit(projectDir) {
+    const detection = detectHarness(projectDir);
+    const categories = detection.harness === "claude" && detection.configDir
+        ? auditClaude(projectDir, detection.configDir)
+        : auditGeneric(projectDir);
+    const totalScore = categories.reduce((s, c) => s + c.score, 0);
+    const maxScore = categories.reduce((s, c) => s + c.maxScore, 0);
+    return {
+        harness: detection.harness,
+        totalScore,
+        maxScore,
+        grade: computeGrade(totalScore, maxScore),
+        categories,
+    };
+}
+//# sourceMappingURL=harness-audit.js.map

package/dist/lib/parallel-batch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parallel batch sub-agents — spawn test/lint/build runners per module
+ * in parallel during quality scoring. Collects results and aggregates.
+ */
+export type JobStatus = "pending" | "running" | "done" | "error";
+export interface BatchJob {
+    id: string;
+    name: string;
+    command: string;
+    module: string;
+    status: JobStatus;
+    startedAt: number | null;
+    completedAt: number | null;
+    durationMs: number;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface BatchResult {
+    jobs: BatchJob[];
+    totalDurationMs: number;
+    passedCount: number;
+    failedCount: number;
+    parallelism: number;
+}
+export interface BatchConfig {
+    maxParallel: number;
+    timeoutMs: number;
+}
+export declare const DEFAULT_BATCH_CONFIG: BatchConfig;
+export declare function createJob(name: string, command: string, module: string): BatchJob;
+export type JobExecutor = (job: BatchJob) => Promise<BatchJob>;
+/**
+ * Default executor — runs command via child_process.
+ */
+export declare function createShellExecutor(timeoutMs?: number): JobExecutor;
+/**
+ * Run jobs in parallel with configurable concurrency.
+ */
+export declare function runBatch(jobs: BatchJob[], executor: JobExecutor, config?: BatchConfig): Promise<BatchResult>;
+export declare function formatBatchResult(result: BatchResult): string;
+//# sourceMappingURL=parallel-batch.d.ts.map

package/dist/lib/parallel-batch.js

@@ -0,0 +1,88 @@
+/**
+ * Parallel batch sub-agents — spawn test/lint/build runners per module
+ * in parallel during quality scoring. Collects results and aggregates.
+ */
+import { execFileAsync } from "./exec.js";
+export const DEFAULT_BATCH_CONFIG = {
+    maxParallel: 4,
+    timeoutMs: 60_000,
+};
+// ── Job creation ──
+let _jobCounter = 0;
+export function createJob(name, command, module) {
+    _jobCounter++;
+    return {
+        id: `job-${Date.now()}-${_jobCounter}`,
+        name,
+        command,
+        module,
+        status: "pending",
+        startedAt: null,
+        completedAt: null,
+        durationMs: 0,
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+    };
+}
+/**
+ * Default executor — runs command via child_process.
+ */
+export function createShellExecutor(timeoutMs = 60_000) {
+    return async (job) => {
+        job.status = "running";
+        job.startedAt = Date.now();
+        try {
+            const { stdout, stderr } = await execFileAsync("sh", ["-c", job.command], { timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 });
+            job.stdout = stdout;
+            job.stderr = stderr;
+            job.exitCode = 0;
+            job.status = "done";
+        }
+        catch (err) {
+            const e = err;
+            job.stdout = e.stdout ?? "";
+            job.stderr = e.stderr ?? "";
+            job.exitCode = e.killed ? -1 : (e.code ?? 1);
+            job.status = "error";
+        }
+        job.completedAt = Date.now();
+        job.durationMs = job.completedAt - job.startedAt;
+        return job;
+    };
+}
+/**
+ * Run jobs in parallel with configurable concurrency.
+ */
+export async function runBatch(jobs, executor, config = DEFAULT_BATCH_CONFIG) {
+    const start = Date.now();
+    const results = [];
+    const queue = [...jobs];
+    // Process in waves of maxParallel
+    while (queue.length > 0) {
+        const wave = queue.splice(0, config.maxParallel);
+        const waveResults = await Promise.all(wave.map((j) => executor(j)));
+        results.push(...waveResults);
+    }
+    return {
+        jobs: results,
+        totalDurationMs: Date.now() - start,
+        passedCount: results.filter((j) => j.status === "done").length,
+        failedCount: results.filter((j) => j.status === "error").length,
+        parallelism: config.maxParallel,
+    };
+}
+// ── Formatting ──
+export function formatBatchResult(result) {
+    const status = result.failedCount === 0 ? "✅ ALL PASSED" : "❌ FAILURES";
+    const lines = [];
+    lines.push(`## Batch Result: ${status}`);
+    lines.push(`**Jobs**: ${result.jobs.length} | **Passed**: ${result.passedCount} | **Failed**: ${result.failedCount} | **Time**: ${result.totalDurationMs}ms | **Parallelism**: ${result.parallelism}`);
+    lines.push("");
+    for (const job of result.jobs) {
+        const icon = job.status === "done" ? "✓" : "✗";
+        lines.push(`  ${icon} ${job.name} (${job.module}) — ${job.durationMs}ms [exit ${job.exitCode}]`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=parallel-batch.js.map

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;