javi-forge 1.6.0 → 1.7.0

package/ci-local/uninstall.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+# =============================================================================
+# CI-LOCAL: Uninstall Script
+# =============================================================================
+# Reverses what install.sh did:
+#   - Unset core.hooksPath
+#   - Optionally restore .git/hooks/ backups (if --restore-backups given)
+#   - Optionally delete the ci-local/ directory (if --purge given)
+#
+# Usage:
+#   ./uninstall.sh                       # only unset core.hooksPath
+#   ./uninstall.sh --restore-backups     # also restore .bak hooks
+#   ./uninstall.sh --purge               # also rm -rf ci-local/ + lib/common.sh
+# =============================================================================
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Source colors if available; degrade gracefully if not.
+if [ -f "$SCRIPT_DIR/../lib/common.sh" ]; then
+    # shellcheck disable=SC1091
+    source "$SCRIPT_DIR/../lib/common.sh" 2>/dev/null || true
+fi
+: "${RED:=}" "${GREEN:=}" "${YELLOW:=}" "${CYAN:=}" "${NC:=}"
+
+RESTORE_BACKUPS=0
+PURGE=0
+for arg in "$@"; do
+    case "$arg" in
+        --restore-backups) RESTORE_BACKUPS=1 ;;
+        --purge)           PURGE=1 ;;
+        --help|-h)
+            echo "Usage: $0 [--restore-backups] [--purge]"
+            exit 0
+            ;;
+        *)
+            echo "Unknown argument: $arg" >&2
+            echo "Usage: $0 [--restore-backups] [--purge]" >&2
+            exit 1
+            ;;
+    esac
+done
+
+cd "$PROJECT_DIR"
+
+echo -e "${CYAN}=== CI-LOCAL Uninstall ===${NC}"
+
+# 1. Unset core.hooksPath if it points at us
+echo -e "${YELLOW}[1/3] Removing core.hooksPath...${NC}"
+current=$(git config --get core.hooksPath 2>/dev/null || echo "")
+if [ -n "$current" ]; then
+    git config --unset core.hooksPath
+    echo -e "${GREEN}Removed hooksPath = $current${NC}"
+else
+    echo -e "${YELLOW}No core.hooksPath was set; nothing to remove${NC}"
+fi
+
+# 2. Restore .bak hooks if requested
+echo -e "${YELLOW}[2/3] Restoring hook backups...${NC}"
+if [ "$RESTORE_BACKUPS" -eq 1 ]; then
+    restored=0
+    for hook in pre-commit commit-msg pre-push; do
+        if [ -f ".git/hooks/$hook.bak" ]; then
+            mv ".git/hooks/$hook.bak" ".git/hooks/$hook"
+            echo -e "${GREEN}Restored .git/hooks/$hook${NC}"
+            restored=$((restored + 1))
+        fi
+    done
+    if [ "$restored" -eq 0 ]; then
+        echo -e "${YELLOW}No .bak hooks found to restore${NC}"
+    fi
+else
+    echo -e "${YELLOW}Skipped (pass --restore-backups to enable)${NC}"
+fi
+
+# 3. Purge ci-local/ directory if requested
+echo -e "${YELLOW}[3/3] Purging ci-local/ directory...${NC}"
+if [ "$PURGE" -eq 1 ]; then
+    if [ -d ".ci-local" ]; then
+        rm -rf ".ci-local"
+        echo -e "${GREEN}Removed .ci-local/${NC}"
+    fi
+    if [ -d "ci-local" ] && [ "$(realpath "$SCRIPT_DIR")" = "$(realpath "$PROJECT_DIR/ci-local")" ]; then
+        echo -e "${YELLOW}WARNING: ci-local/ directory contains THIS uninstall script.${NC}"
+        echo -e "${YELLOW}Refusing to delete it. Remove manually after this script exits.${NC}"
+    fi
+else
+    echo -e "${YELLOW}Skipped (pass --purge to delete directories)${NC}"
+fi
+
+echo -e ""
+echo -e "${GREEN}Uninstall complete!${NC}"
+echo -e ""

package/dist/cli/dispatch/ci.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `javi-forge ci` handler — two branches:
+ *   1. `ci init` — console-only, installs git hooks via ./commands/ci.js (lazy)
+ *   2. `ci [--detect|--shell|--quick|...]` — Ink render of <CI /> (eager)
+ *
+ * The command module (`./commands/ci.js`) is lazy-loaded inside the function
+ * to preserve cold-start performance; Ink + React are already eagerly loaded
+ * at the entrypoint, so importing the UI component at the top is fine.
+ */
+import type { CLI, RendererCtx } from "./types.js";
+export declare function handleCi(cli: CLI, ctx: RendererCtx): Promise<void>;
+//# sourceMappingURL=ci.d.ts.map

package/dist/cli/dispatch/ci.js

@@ -0,0 +1,38 @@
+/**
+ * `javi-forge ci` handler — two branches:
+ *   1. `ci init` — console-only, installs git hooks via ./commands/ci.js (lazy)
+ *   2. `ci [--detect|--shell|--quick|...]` — Ink render of <CI /> (eager)
+ *
+ * The command module (`./commands/ci.js`) is lazy-loaded inside the function
+ * to preserve cold-start performance; Ink + React are already eagerly loaded
+ * at the entrypoint, so importing the UI component at the top is fine.
+ */
+import { render } from "ink";
+import React from "react";
+import CI from "../../ui/CI.js";
+import { CIProvider as CIContextProvider } from "../../ui/CIContext.js";
+export async function handleCi(cli, ctx) {
+    // Sub-command: javi-forge ci init → install git hooks
+    if (cli.input[1] === "init") {
+        const { installCIHooks } = await import("../../commands/ci.js");
+        const { installed, errors } = await installCIHooks(process.cwd());
+        if (installed.length > 0) {
+            console.log(`✓ Installed git hooks: ${installed.join(", ")}`);
+            console.log("  Hooks call javi-forge ci (with npx fallback)");
+        }
+        for (const err of errors) {
+            console.error(`✗ ${err}`);
+        }
+        process.exit(errors.length > 0 ? 1 : 0);
+    }
+    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, config: cli.flags.config || undefined, stack: cli.flags.stack || undefined })), { stdin: ctx.inkStdin });
+}
+//# sourceMappingURL=ci.js.map

package/dist/cli/dispatch/security.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `javi-forge security <baseline|check|update|allowlist>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../commands/security.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ */
+import type { CLI } from "./types.js";
+export declare function handleSecurity(cli: CLI): Promise<void>;
+//# sourceMappingURL=security.d.ts.map

package/dist/cli/dispatch/security.js

@@ -0,0 +1,68 @@
+/**
+ * `javi-forge security <baseline|check|update|allowlist>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../commands/security.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ */
+import { VALID_SECURITY_ACTIONS } from "../validators.js";
+export async function handleSecurity(cli) {
+    const securityAction = cli.input[1];
+    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);
+    }
+    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);
+    }
+}
+//# sourceMappingURL=security.js.map

package/dist/cli/dispatch/simple-renderers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Trivial Ink renderers for CLI subcommands.
+ *
+ * Each handler is a thin wrapper around `render(<Provider><Component .../></Provider>)`.
+ * Grouped here because the bodies are 5-10 LOC apiece and share the same shape.
+ *
+ * Ink + React are already eagerly imported at the entrypoint, so importing the
+ * concrete UI components at the top of this file does NOT worsen cold-start.
+ */
+import type { CLI, RendererCtx } from "./types.js";
+export declare function handleDoctor(_cli: CLI, ctx: RendererCtx): void;
+export declare function handleAnalyze(cli: CLI, ctx: RendererCtx): void;
+export declare function handleLlmsTxt(cli: CLI, ctx: RendererCtx): void;
+export declare function handlePlugin(cli: CLI, ctx: RendererCtx): void;
+export declare function handleInitDefault(cli: CLI, ctx: RendererCtx): void;
+//# sourceMappingURL=simple-renderers.d.ts.map

package/dist/cli/dispatch/simple-renderers.js

@@ -0,0 +1,65 @@
+/**
+ * Trivial Ink renderers for CLI subcommands.
+ *
+ * Each handler is a thin wrapper around `render(<Provider><Component .../></Provider>)`.
+ * Grouped here because the bodies are 5-10 LOC apiece and share the same shape.
+ *
+ * Ink + React are already eagerly imported at the entrypoint, so importing the
+ * concrete UI components at the top of this file does NOT worsen cold-start.
+ */
+import { render } from "ink";
+import React from "react";
+import AnalyzeUI from "../../ui/AnalyzeUI.js";
+import App from "../../ui/App.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 { VALID_CI, VALID_MEMORY, VALID_STACKS } from "../validators.js";
+export function handleDoctor(_cli, ctx) {
+    render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+        React.createElement(Doctor, null)), { stdin: ctx.inkStdin });
+}
+export function handleAnalyze(cli, ctx) {
+    render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+        React.createElement(AnalyzeUI, { dryRun: cli.flags.dryRun })), { stdin: ctx.inkStdin });
+}
+export function handleLlmsTxt(cli, ctx) {
+    render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+        React.createElement(LlmsTxt, { projectDir: process.cwd(), dryRun: cli.flags.dryRun })), { stdin: ctx.inkStdin });
+}
+export function handlePlugin(cli, ctx) {
+    const pluginAction = cli.input[1];
+    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: ctx.isCI },
+        React.createElement(Plugin, { action: action, target: target, dryRun: cli.flags.dryRun, codex: cli.flags.codex })), { stdin: ctx.inkStdin });
+}
+export function handleInitDefault(cli, ctx) {
+    const presetStack = VALID_STACKS.includes(cli.flags.stack)
+        ? cli.flags.stack
+        : undefined;
+    const presetCI = VALID_CI.includes(cli.flags.ci)
+        ? cli.flags.ci
+        : undefined;
+    const presetMemory = VALID_MEMORY.includes(cli.flags.memory)
+        ? cli.flags.memory
+        : undefined;
+    const presetName = cli.flags.projectName || undefined;
+    render(React.createElement(CIContextProvider, { isCI: ctx.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, presetLocalAi: cli.flags.localAi ?? false })), { stdin: ctx.inkStdin });
+}
+//# sourceMappingURL=simple-renderers.js.map

package/dist/cli/dispatch/skill-publish.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `javi-forge skill publish [dir]` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../lib/skill-publish.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ *
+ * The case label in src/index.tsx is `"skill"` (with `publish` as the only
+ * supported subcommand); the handler is named `handleSkillPublish` for clarity
+ * since "skill" alone is ambiguous next to the `skills` command group.
+ */
+import type { CLI } from "./types.js";
+export declare function handleSkillPublish(cli: CLI): Promise<void>;
+//# sourceMappingURL=skill-publish.d.ts.map

package/dist/cli/dispatch/skill-publish.js

@@ -0,0 +1,44 @@
+/**
+ * `javi-forge skill publish [dir]` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../lib/skill-publish.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ *
+ * The case label in src/index.tsx is `"skill"` (with `publish` as the only
+ * supported subcommand); the handler is named `handleSkillPublish` for clarity
+ * since "skill" alone is ambiguous next to the `skills` command group.
+ */
+import path from "node:path";
+export async function handleSkillPublish(cli) {
+    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);
+    }
+    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);
+    }
+}
+//# sourceMappingURL=skill-publish.js.map

package/dist/cli/dispatch/skills-cmd.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `javi-forge skills` handler — three branches:
+ *   1. `skills auto` / `skills auto-install` — Ink render of <AutoSkills /> (eager)
+ *   2. `skills score` / `skills benchmark` — console-only, lazy-loads ./commands/skills.js
+ *   3. `skills doctor` / `skills budget` — Ink render of <Skills mode=... /> (eager)
+ *
+ * The command module (`./commands/skills.js`) is lazy-loaded inside the function
+ * to preserve cold-start performance for the Ink branches. Ink + React are
+ * already eagerly loaded by the entrypoint, so the UI components stay eager.
+ */
+import type { CLI, RendererCtx } from "./types.js";
+export declare function handleSkillsCmd(cli: CLI, ctx: RendererCtx): Promise<void>;
+//# sourceMappingURL=skills-cmd.d.ts.map

package/dist/cli/dispatch/skills-cmd.js

@@ -0,0 +1,93 @@
+/**
+ * `javi-forge skills` handler — three branches:
+ *   1. `skills auto` / `skills auto-install` — Ink render of <AutoSkills /> (eager)
+ *   2. `skills score` / `skills benchmark` — console-only, lazy-loads ./commands/skills.js
+ *   3. `skills doctor` / `skills budget` — Ink render of <Skills mode=... /> (eager)
+ *
+ * The command module (`./commands/skills.js`) is lazy-loaded inside the function
+ * to preserve cold-start performance for the Ink branches. Ink + React are
+ * already eagerly loaded by the entrypoint, so the UI components stay eager.
+ */
+import path from "node:path";
+import { render } from "ink";
+import React from "react";
+import AutoSkills from "../../ui/AutoSkills.js";
+import { CIProvider as CIContextProvider } from "../../ui/CIContext.js";
+import Skills from "../../ui/Skills.js";
+const VALID_SKILLS_ACTIONS = [
+    "doctor",
+    "budget",
+    "score",
+    "benchmark",
+    "auto",
+    "auto-install",
+];
+export async function handleSkillsCmd(cli, ctx) {
+    const skillsAction = cli.input[1];
+    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);
+    }
+    // Auto / auto-install: render interactive Ink UI
+    if (skillsAction === "auto" || skillsAction === "auto-install") {
+        render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+            React.createElement(AutoSkills, { projectDir: process.cwd(), skillsDir: cli.flags.skillsDir || undefined, dryRun: cli.flags.dryRun })), { stdin: ctx.inkStdin });
+        return;
+    }
+    // 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);
+        }
+        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);
+            }
+            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);
+        }
+        const { benchmarkSkill } = await import("../../commands/skills.js");
+        const result = await benchmarkSkill(skillPath);
+        if (!result) {
+            console.error(`\u2717 Skill not found: ${skillPath}`);
+            process.exit(1);
+        }
+        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);
+    }
+    // Doctor / budget: render Ink UI with mode prop
+    const skillsMode = skillsAction;
+    render(React.createElement(CIContextProvider, { isCI: ctx.isCI },
+        React.createElement(Skills, { mode: skillsMode, budget: cli.flags.budget, deep: cli.flags.deep, skillsDir: cli.flags.skillsDir || undefined })), { stdin: ctx.inkStdin });
+}
+//# sourceMappingURL=skills-cmd.js.map

package/dist/cli/dispatch/tdd.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `javi-forge tdd <init|pipeline>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ./commands/tdd.js or ./commands/tdd-pipeline.js INSIDE the function
+ * to preserve cold-start performance — heavy command modules MUST NOT be
+ * eager-imported at the top of this file.
+ */
+import type { CLI } from "./types.js";
+export declare function handleTdd(cli: CLI): Promise<void>;
+//# sourceMappingURL=tdd.d.ts.map

package/dist/cli/dispatch/tdd.js

@@ -0,0 +1,45 @@
+/**
+ * `javi-forge tdd <init|pipeline>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ./commands/tdd.js or ./commands/tdd-pipeline.js INSIDE the function
+ * to preserve cold-start performance — heavy command modules MUST NOT be
+ * eager-imported at the top of this file.
+ */
+export async function handleTdd(cli) {
+    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);
+    }
+}
+//# sourceMappingURL=tdd.js.map

package/dist/cli/dispatch/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared types for the CLI dispatch layer.
+ *
+ * `CLI` is the meow `Result` parameterized over FLAGS_SCHEMA — imported
+ * by all dispatch handlers for the `cli` parameter type.
+ *
+ * `RendererCtx` carries the Ink-render-specific context (stdin shim +
+ * CI flag) — imported by Ink-rendering handlers only.
+ */
+import type { Result } from "meow";
+import type { FLAGS_SCHEMA } from "../help.js";
+/**
+ * Type of the meow `Result` parameterized over our FLAGS_SCHEMA.
+ * Shared by all dispatch handlers as the `cli` parameter type.
+ */
+export type CLI = Result<typeof FLAGS_SCHEMA>;
+/**
+ * Context passed to dispatch handlers that need to render Ink components.
+ * - `inkStdin`: the (possibly shimmed) stdin used by Ink's render — built via
+ *   `createInkStdin()` in `src/cli/runtime.ts` (a `PassThrough` stand-in when
+ *   stdin is not a TTY, the real `process.stdin` otherwise).
+ * - `isCI`: controls `CIContextProvider` behavior — derived from
+ *   `detectCI(cli.flags)` in `src/cli/runtime.ts`.
+ */
+export type RendererCtx = {
+    inkStdin: NodeJS.ReadStream;
+    isCI: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/dispatch/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/dispatch/workflow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `javi-forge workflow <show|validate|list>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../commands/workflow.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ */
+import type { CLI } from "./types.js";
+export declare function handleWorkflow(cli: CLI): Promise<void>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/cli/dispatch/workflow.js

@@ -0,0 +1,67 @@
+/**
+ * `javi-forge workflow <show|validate|list>` handler.
+ *
+ * Console-only (no Ink, no React, no CIContextProvider).
+ * Lazy-loads ../../commands/workflow.js INSIDE the function to preserve
+ * cold-start performance — heavy command modules MUST NOT be eager-imported
+ * at the top of this file.
+ */
+export async function handleWorkflow(cli) {
+    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);
+    }
+    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);
+    }
+}
+//# sourceMappingURL=workflow.js.map