javi-forge 1.5.0 → 1.6.1

package/dist/commands/team-presets.js

@@ -0,0 +1,201 @@
+/**
+ * Agent Teams parallel dispatch presets — predefined team configurations
+ * for common workflows like review, debug, and security scanning.
+ *
+ * Each preset defines which sub-agents to spawn in parallel, their roles,
+ * and how to aggregate results.
+ */
+// ── Built-in presets ──
+export const TEAM_PRESETS = {
+    review: {
+        name: "review",
+        description: "Multi-perspective code review team",
+        roles: [
+            {
+                id: "quality",
+                name: "Quality Reviewer",
+                skill: "adversarial-review",
+                perspective: "code quality, readability, maintainability",
+                priority: "high",
+            },
+            {
+                id: "security",
+                name: "Security Auditor",
+                skill: "adversarial-review",
+                perspective: "security vulnerabilities, injection, auth",
+                priority: "critical",
+            },
+            {
+                id: "testing",
+                name: "Test Reviewer",
+                skill: "testing:test-coverage",
+                perspective: "test coverage, edge cases, test quality",
+                priority: "medium",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 3,
+    },
+    debug: {
+        name: "debug",
+        description: "Parallel debugging team",
+        roles: [
+            {
+                id: "hypothesis",
+                name: "Hypothesis Generator",
+                skill: "debug-mode",
+                perspective: "generate and rank failure hypotheses",
+                priority: "high",
+            },
+            {
+                id: "logs",
+                name: "Log Analyzer",
+                skill: "debug-mode",
+                perspective: "parse logs, stack traces, error patterns",
+                priority: "high",
+            },
+            {
+                id: "repro",
+                name: "Reproducer",
+                skill: "testing:e2e",
+                perspective: "create minimal reproduction steps",
+                priority: "medium",
+            },
+        ],
+        aggregation: "any-pass",
+        maxParallel: 3,
+    },
+    security: {
+        name: "security",
+        description: "Security scanning team",
+        roles: [
+            {
+                id: "sast",
+                name: "SAST Scanner",
+                skill: "adversarial-review",
+                perspective: "static analysis, code patterns, OWASP",
+                priority: "critical",
+            },
+            {
+                id: "deps",
+                name: "Dependency Auditor",
+                skill: "adversarial-review",
+                perspective: "supply chain, outdated deps, known CVEs",
+                priority: "critical",
+            },
+            {
+                id: "secrets",
+                name: "Secret Scanner",
+                skill: "adversarial-review",
+                perspective: "hardcoded secrets, API keys, credentials",
+                priority: "critical",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 3,
+    },
+    "tdd-cycle": {
+        name: "tdd-cycle",
+        description: "TDD pipeline team",
+        roles: [
+            {
+                id: "test-writer",
+                name: "Test Writer",
+                skill: "testing:tdd",
+                perspective: "write failing tests first",
+                priority: "high",
+            },
+            {
+                id: "implementer",
+                name: "Implementer",
+                skill: "sdd-apply",
+                perspective: "make tests pass with minimal code",
+                priority: "high",
+            },
+            {
+                id: "refactorer",
+                name: "Refactorer",
+                skill: "refactoring:cleanup",
+                perspective: "clean up without breaking tests",
+                priority: "medium",
+            },
+        ],
+        aggregation: "all-must-pass",
+        maxParallel: 1, // sequential for TDD
+    },
+};
+// ── Preset management ──
+export function getPreset(name) {
+    return TEAM_PRESETS[name] ?? null;
+}
+export function listPresets() {
+    return Object.values(TEAM_PRESETS).map((p) => ({
+        name: p.name,
+        description: p.description,
+        roleCount: p.roles.length,
+    }));
+}
+// ── Dispatch creation ──
+export function createDispatch(presetName, targetFiles, context = {}) {
+    const preset = getPreset(presetName);
+    if (!preset)
+        return null;
+    return {
+        preset: presetName,
+        roles: preset.roles,
+        targetFiles,
+        context,
+    };
+}
+// ── Result aggregation ──
+export function aggregateResults(preset, results) {
+    const totalDurationMs = Math.max(...results.map((r) => r.durationMs), 0);
+    let passed;
+    switch (preset.aggregation) {
+        case "all-must-pass":
+            passed = results.every((r) => r.passed);
+            break;
+        case "majority":
+            passed = results.filter((r) => r.passed).length > results.length / 2;
+            break;
+        case "any-pass":
+            passed = results.some((r) => r.passed);
+            break;
+    }
+    const criticalFindings = results
+        .filter((r) => r.severity === "critical" && !r.passed)
+        .flatMap((r) => r.findings);
+    const summary = passed
+        ? `All ${results.length} agents passed.`
+        : `${results.filter((r) => !r.passed).length}/${results.length} agents reported issues.${criticalFindings.length > 0 ? ` ${criticalFindings.length} critical findings.` : ""}`;
+    return {
+        preset: preset.name,
+        passed,
+        agents: results,
+        totalDurationMs,
+        summary,
+    };
+}
+// ── Formatting ──
+export function formatTeamResult(result) {
+    const icon = result.passed ? "✅" : "❌";
+    const lines = [
+        `${icon} Team: ${result.preset} — ${result.summary}`,
+        "",
+    ];
+    for (const agent of result.agents) {
+        const aIcon = agent.passed ? "✓" : "✗";
+        const dur = `${(agent.durationMs / 1000).toFixed(1)}s`;
+        lines.push(`  ${aIcon} ${agent.roleName} [${agent.severity}] ${dur}`);
+        if (agent.findings.length > 0) {
+            for (const f of agent.findings.slice(0, 3)) {
+                lines.push(`    - ${f}`);
+            }
+            if (agent.findings.length > 3) {
+                lines.push(`    ... +${agent.findings.length - 3} more`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=team-presets.js.map

package/dist/commands/workflow.d.ts

@@ -0,0 +1,23 @@
+import type { InitStep } from "../types/index.js";
+export type WorkflowAction = "show" | "validate" | "list";
+type StepCallback = (step: InitStep) => void;
+/**
+ * Show a workflow graph as ASCII art.
+ */
+export declare function runWorkflowShow(projectDir: string, onStep: StepCallback, options?: {
+    target?: string;
+    template?: string;
+}): Promise<string | null>;
+/**
+ * Validate a project against a workflow graph.
+ */
+export declare function runWorkflowValidate(projectDir: string, onStep: StepCallback, options?: {
+    target?: string;
+    template?: string;
+}): Promise<string | null>;
+/**
+ * List available workflows (project + built-in templates).
+ */
+export declare function runWorkflowList(projectDir: string, onStep: StepCallback): Promise<string>;
+export {};
+//# sourceMappingURL=workflow.d.ts.map

package/dist/commands/workflow.js

@@ -0,0 +1,114 @@
+import fs from "fs-extra";
+import { discoverWorkflows, getAvailableChecks, listBuiltinTemplates, loadBuiltinTemplate, parseDot, parseMermaid, renderAscii, validateWorkflow, } from "../lib/workflow/index.js";
+function report(onStep, id, label, status, detail) {
+    onStep({ id, label, status, detail });
+}
+/**
+ * Resolve a workflow graph from either a file path or a built-in template name.
+ */
+async function resolveGraph(target, projectDir, template, onStep) {
+    // Option 1: Built-in template
+    if (template) {
+        report(onStep, "resolve", `Loading template: ${template}`, "running");
+        const tpl = await loadBuiltinTemplate(template);
+        if (!tpl) {
+            report(onStep, "resolve", `Loading template: ${template}`, "error", `Template "${template}" not found`);
+            return null;
+        }
+        const parser = tpl.format === "dot" ? parseDot : parseMermaid;
+        const graph = parser(tpl.content, template);
+        report(onStep, "resolve", `Loading template: ${template}`, "done", `${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+        return graph;
+    }
+    // Option 2: Explicit file path
+    if (target) {
+        report(onStep, "resolve", `Loading workflow: ${target}`, "running");
+        if (!(await fs.pathExists(target))) {
+            report(onStep, "resolve", `Loading workflow: ${target}`, "error", "File not found");
+            return null;
+        }
+        const content = await fs.readFile(target, "utf-8");
+        const isDot = target.endsWith(".dot");
+        const parser = isDot ? parseDot : parseMermaid;
+        const name = target
+            .split("/")
+            .pop()
+            ?.replace(/\.\w+$/, "") ?? "workflow";
+        const graph = parser(content, name);
+        report(onStep, "resolve", `Loading workflow: ${target}`, "done", `${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+        return graph;
+    }
+    // Option 3: Auto-discover first workflow in project
+    report(onStep, "resolve", "Discovering workflows", "running");
+    const discovered = await discoverWorkflows(projectDir);
+    if (discovered.length === 0) {
+        report(onStep, "resolve", "Discovering workflows", "error", "No workflows found in .javi-forge/workflows/");
+        return null;
+    }
+    const first = discovered[0];
+    const content = await fs.readFile(first.path, "utf-8");
+    const parser = first.format === "dot" ? parseDot : parseMermaid;
+    const graph = parser(content, first.name);
+    report(onStep, "resolve", "Discovering workflows", "done", `Using ${first.name} (${graph.nodes.length} nodes)`);
+    return graph;
+}
+/**
+ * Show a workflow graph as ASCII art.
+ */
+export async function runWorkflowShow(projectDir, onStep, options = {}) {
+    const graph = await resolveGraph(options.target, projectDir, options.template, onStep);
+    if (!graph)
+        return null;
+    report(onStep, "render", "Rendering graph", "running");
+    const ascii = renderAscii(graph);
+    report(onStep, "render", "Rendering graph", "done");
+    return ascii;
+}
+/**
+ * Validate a project against a workflow graph.
+ */
+export async function runWorkflowValidate(projectDir, onStep, options = {}) {
+    const graph = await resolveGraph(options.target, projectDir, options.template, onStep);
+    if (!graph)
+        return null;
+    report(onStep, "validate", "Validating workflow", "running");
+    const results = await validateWorkflow(graph, projectDir);
+    report(onStep, "validate", "Validating workflow", "done");
+    const ascii = renderAscii(graph, results);
+    return ascii;
+}
+/**
+ * List available workflows (project + built-in templates).
+ */
+export async function runWorkflowList(projectDir, onStep) {
+    report(onStep, "list", "Listing workflows", "running");
+    const project = await discoverWorkflows(projectDir);
+    const builtin = await listBuiltinTemplates();
+    const checks = getAvailableChecks();
+    const lines = [];
+    if (project.length > 0) {
+        lines.push("Project workflows (.javi-forge/workflows/):");
+        for (const w of project) {
+            lines.push(`  - ${w.name} (${w.format})`);
+        }
+    }
+    else {
+        lines.push("No project workflows found.");
+        lines.push("  Create .javi-forge/workflows/*.dot or *.mermaid");
+    }
+    lines.push("");
+    if (builtin.length > 0) {
+        lines.push("Built-in templates (use --template <name>):");
+        for (const t of builtin) {
+            lines.push(`  - ${t.name} (${t.format})`);
+        }
+    }
+    lines.push("");
+    lines.push("Available validation checks:");
+    for (const c of checks) {
+        lines.push(`  - ${c}`);
+    }
+    report(onStep, "list", "Listing workflows", "done");
+    return lines.join("\n");
+}
+//# sourceMappingURL=workflow.js.map

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
+import type { HookProfile, StackClaudeMdEntry, StackContextEntry } from "./types/index.js";
 /** Root of the javi-forge package (one level up from dist/) */
 export declare const FORGE_ROOT: string;
 /** Templates directory */
@@ -8,6 +9,10 @@ export declare const MODULES_DIR: string;
 export declare const WORKFLOWS_DIR: string;
 /** CI-local directory */
 export declare const CI_LOCAL_DIR: string;
+/** Security hooks template directory */
+export declare const SECURITY_HOOKS_DIR: string;
+/** Local AI stack template directory */
+export declare const LOCAL_AI_TEMPLATE_DIR: string;
 /** Dependabot fragment directory */
 export declare const DEPENDABOT_FRAGMENTS_DIR: string;
 /** Plugins directory (installed plugins) */
@@ -18,8 +23,24 @@ export declare const PLUGIN_REGISTRY_URL = "https://raw.githubusercontent.com/JN
 export declare const PLUGIN_MANIFEST_FILE = "plugin.json";
 /** Valid plugin asset directories */
 export declare const PLUGIN_ASSET_DIRS: readonly ["skills", "commands", "hooks", "agents"];
+/** Agent Skills spec manifest filename */
+export declare const AGENT_SKILLS_MANIFEST_FILE = "skills.json";
 /** Stack-to-dependabot fragment mapping */
 export declare const STACK_DEPENDABOT_MAP: Record<string, string[]>;
+/** Stack-to-CLAUDE.md metadata mapping */
+export declare const STACK_CLAUDEMD_MAP: Record<string, StackClaudeMdEntry>;
+/** Stack-to-context template mapping */
+export declare const STACK_CONTEXT_MAP: Record<string, StackContextEntry>;
+/** Deploy template filename mapping (per CI provider) */
+export declare const DEPLOY_TEMPLATE_MAP: Record<string, string>;
+/** Deploy destination path mapping (per CI provider) */
+export declare const DEPLOY_DESTINATION_MAP: Record<string, string>;
+/** Hook reliability profile definitions */
+export declare const HOOK_PROFILES: Record<HookProfile, {
+    label: string;
+    description: string;
+    hooks: string[];
+}>;
 /** Stack-to-CI template filename mapping */
 export declare const STACK_CI_MAP: Record<string, Record<string, string>>;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,61 +1,232 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
+import path from "path";
+import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /** Root of the javi-forge package (one level up from dist/) */
-export const FORGE_ROOT = path.resolve(__dirname, '..');
+export const FORGE_ROOT = path.resolve(__dirname, "..");
 /** Templates directory */
-export const TEMPLATES_DIR = path.join(FORGE_ROOT, 'templates');
+export const TEMPLATES_DIR = path.join(FORGE_ROOT, "templates");
 /** Modules directory */
-export const MODULES_DIR = path.join(FORGE_ROOT, 'modules');
+export const MODULES_DIR = path.join(FORGE_ROOT, "modules");
 /** Workflows directory */
-export const WORKFLOWS_DIR = path.join(FORGE_ROOT, 'workflows');
+export const WORKFLOWS_DIR = path.join(FORGE_ROOT, "workflows");
 /** CI-local directory */
-export const CI_LOCAL_DIR = path.join(FORGE_ROOT, 'ci-local');
+export const CI_LOCAL_DIR = path.join(FORGE_ROOT, "ci-local");
+/** Security hooks template directory */
+export const SECURITY_HOOKS_DIR = path.join(TEMPLATES_DIR, "security-hooks");
+/** Local AI stack template directory */
+export const LOCAL_AI_TEMPLATE_DIR = path.join(TEMPLATES_DIR, "local-ai");
 /** Dependabot fragment directory */
-export const DEPENDABOT_FRAGMENTS_DIR = path.join(TEMPLATES_DIR, 'common', 'dependabot');
+export const DEPENDABOT_FRAGMENTS_DIR = path.join(TEMPLATES_DIR, "common", "dependabot");
 /** Plugins directory (installed plugins) */
-export const PLUGINS_DIR = path.join(FORGE_ROOT, 'plugins');
+export const PLUGINS_DIR = path.join(FORGE_ROOT, "plugins");
 /** Plugin registry URL */
-export const PLUGIN_REGISTRY_URL = 'https://raw.githubusercontent.com/JNZader/javi-forge-registry/main/registry.json';
+export const PLUGIN_REGISTRY_URL = "https://raw.githubusercontent.com/JNZader/javi-forge-registry/main/registry.json";
 /** Plugin manifest filename */
-export const PLUGIN_MANIFEST_FILE = 'plugin.json';
+export const PLUGIN_MANIFEST_FILE = "plugin.json";
 /** Valid plugin asset directories */
-export const PLUGIN_ASSET_DIRS = ['skills', 'commands', 'hooks', 'agents'];
+export const PLUGIN_ASSET_DIRS = [
+    "skills",
+    "commands",
+    "hooks",
+    "agents",
+];
+/** Agent Skills spec manifest filename */
+export const AGENT_SKILLS_MANIFEST_FILE = "skills.json";
 /** Stack-to-dependabot fragment mapping */
 export const STACK_DEPENDABOT_MAP = {
-    'node': ['npm'],
-    'python': ['pip'],
-    'go': ['gomod'],
-    'rust': ['cargo'],
-    'java-gradle': ['gradle'],
-    'java-maven': ['maven'],
-    'elixir': [],
+    node: ["npm"],
+    python: ["pip"],
+    go: ["gomod"],
+    rust: ["cargo"],
+    "java-gradle": ["gradle"],
+    "java-maven": ["maven"],
+    elixir: [],
+};
+/** Stack-to-CLAUDE.md metadata mapping */
+export const STACK_CLAUDEMD_MAP = {
+    node: {
+        skills: ["typescript", "react-19", "tailwind-4"],
+        conventions: "TypeScript strict, ESM modules, functional components",
+        testFramework: "vitest",
+    },
+    python: {
+        skills: ["pytest", "django-drf"],
+        conventions: "PEP 8, type hints, ruff linting",
+        testFramework: "pytest",
+    },
+    go: {
+        skills: [],
+        conventions: "gofmt, golangci-lint, table-driven tests",
+        testFramework: "go test",
+    },
+    rust: {
+        skills: [],
+        conventions: "cargo fmt, clippy, edition 2021+",
+        testFramework: "cargo test",
+    },
+    "java-gradle": {
+        skills: [],
+        conventions: "Gradle Kotlin DSL, JUnit 5, Checkstyle",
+        testFramework: "JUnit 5",
+    },
+    "java-maven": {
+        skills: [],
+        conventions: "Maven standard layout, JUnit 5, Checkstyle",
+        testFramework: "JUnit 5",
+    },
+    elixir: {
+        skills: [],
+        conventions: "mix format, Credo, OTP conventions",
+        testFramework: "ExUnit",
+    },
+    default: {
+        skills: [],
+        conventions: "Follow language-specific best practices",
+        testFramework: "project default",
+    },
+};
+/** Stack-to-context template mapping */
+export const STACK_CONTEXT_MAP = {
+    node: {
+        tree: [
+            "src/           — source code",
+            "  index.ts     — entry point",
+            "tests/         — test suites",
+            "package.json   — dependencies & scripts",
+            "tsconfig.json  — TypeScript config",
+        ].join("\n"),
+        conventions: "TypeScript strict, ESM modules, vitest for testing",
+        entryPoint: "src/index.ts",
+    },
+    python: {
+        tree: [
+            "src/           — source packages",
+            "  __init__.py  — package root",
+            "tests/         — pytest suites",
+            "pyproject.toml — project config",
+        ].join("\n"),
+        conventions: "PEP 8, type hints, pytest, ruff for linting",
+        entryPoint: "src/__init__.py",
+    },
+    go: {
+        tree: [
+            "cmd/           — CLI entry points",
+            "internal/      — private packages",
+            "pkg/           — public packages",
+            "go.mod         — module definition",
+            "go.sum         — dependency checksums",
+        ].join("\n"),
+        conventions: "gofmt, golangci-lint, table-driven tests",
+        entryPoint: "cmd/main.go",
+    },
+    rust: {
+        tree: [
+            "src/           — source code",
+            "  main.rs      — entry point",
+            "  lib.rs       — library root",
+            "tests/         — integration tests",
+            "Cargo.toml     — manifest & dependencies",
+        ].join("\n"),
+        conventions: "cargo fmt, clippy lints, edition 2021+",
+        entryPoint: "src/main.rs",
+    },
+    "java-gradle": {
+        tree: [
+            "src/main/java/       — application source",
+            "src/test/java/       — test source",
+            "src/main/resources/  — config & assets",
+            "build.gradle.kts     — Gradle build script",
+            "settings.gradle.kts  — project settings",
+        ].join("\n"),
+        conventions: "Gradle Kotlin DSL, JUnit 5, Checkstyle",
+        entryPoint: "src/main/java/Main.java",
+    },
+    "java-maven": {
+        tree: [
+            "src/main/java/       — application source",
+            "src/test/java/       — test source",
+            "src/main/resources/  — config & assets",
+            "pom.xml              — Maven POM",
+        ].join("\n"),
+        conventions: "Maven standard layout, JUnit 5, Checkstyle",
+        entryPoint: "src/main/java/Main.java",
+    },
+    elixir: {
+        tree: [
+            "lib/           — application source",
+            "  application.ex — OTP application",
+            "test/          — ExUnit tests",
+            "config/        — runtime config",
+            "mix.exs        — project definition",
+        ].join("\n"),
+        conventions: "mix format, Credo, ExUnit, OTP conventions",
+        entryPoint: "lib/application.ex",
+    },
+    default: {
+        tree: [
+            "src/           — source code",
+            "tests/         — test suites",
+            "README.md      — project documentation",
+        ].join("\n"),
+        conventions: "Follow language-specific best practices",
+        entryPoint: "src/index",
+    },
+};
+/** Deploy template filename mapping (per CI provider) */
+export const DEPLOY_TEMPLATE_MAP = {
+    github: "deploy-docker-zero-downtime.yml",
+    gitlab: "deploy-docker-zero-downtime.yml",
+    woodpecker: "deploy-docker-zero-downtime.yml",
+};
+/** Deploy destination path mapping (per CI provider) */
+export const DEPLOY_DESTINATION_MAP = {
+    github: ".github/workflows/deploy.yml",
+    gitlab: ".gitlab-ci-deploy.yml",
+    woodpecker: ".woodpecker/deploy.yml",
+};
+/** Hook reliability profile definitions */
+export const HOOK_PROFILES = {
+    minimal: {
+        label: "Minimal",
+        description: "pre-commit only: lint + format check",
+        hooks: ["pre-commit"],
+    },
+    standard: {
+        label: "Standard",
+        description: "pre-commit + pre-push + CI gate check",
+        hooks: ["pre-commit", "pre-push", "ci-gate"],
+    },
+    strict: {
+        label: "Strict",
+        description: "all standard + commit-msg validation + security scan on every push",
+        hooks: ["pre-commit", "pre-push", "ci-gate", "commit-msg", "security-scan"],
+    },
 };
 /** Stack-to-CI template filename mapping */
 export const STACK_CI_MAP = {
     github: {
-        'node': 'ci-node.yml',
-        'python': 'ci-python.yml',
-        'go': 'ci-go.yml',
-        'rust': 'ci-rust.yml',
-        'java-gradle': 'ci-java.yml',
-        'java-maven': 'ci-java.yml',
+        node: "ci-node.yml",
+        python: "ci-python.yml",
+        go: "ci-go.yml",
+        rust: "ci-rust.yml",
+        "java-gradle": "ci-java.yml",
+        "java-maven": "ci-java.yml",
     },
     gitlab: {
-        'node': 'gitlab-ci-node.yml',
-        'python': 'gitlab-ci-python.yml',
-        'go': 'gitlab-ci-go.yml',
-        'rust': 'gitlab-ci-rust.yml',
-        'java-gradle': 'gitlab-ci-java.yml',
-        'java-maven': 'gitlab-ci-java.yml',
+        node: "gitlab-ci-node.yml",
+        python: "gitlab-ci-python.yml",
+        go: "gitlab-ci-go.yml",
+        rust: "gitlab-ci-rust.yml",
+        "java-gradle": "gitlab-ci-java.yml",
+        "java-maven": "gitlab-ci-java.yml",
     },
     woodpecker: {
-        'node': 'woodpecker-node.yml',
-        'python': 'woodpecker-python.yml',
-        'go': 'woodpecker-go.yml',
-        'rust': 'woodpecker-rust.yml',
-        'java-gradle': 'woodpecker-java.yml',
-        'java-maven': 'woodpecker-java.yml',
+        node: "woodpecker-node.yml",
+        python: "woodpecker-python.yml",
+        go: "woodpecker-go.yml",
+        rust: "woodpecker-rust.yml",
+        "java-gradle": "woodpecker-java.yml",
+        "java-maven": "woodpecker-java.yml",
     },
 };
 //# sourceMappingURL=constants.js.map