javi-forge 1.5.0 → 1.6.1

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
-export type Stack = 'node' | 'python' | 'go' | 'rust' | 'java-gradle' | 'java-maven' | 'elixir';
-export type CIProvider = 'github' | 'gitlab' | 'woodpecker';
-export type MemoryOption = 'engram' | 'obsidian-brain' | 'memory-simple' | 'none';
+export type Stack = "node" | "python" | "go" | "rust" | "java-gradle" | "java-maven" | "elixir";
+export type CIProvider = "github" | "gitlab" | "woodpecker";
+export type MemoryOption = "engram" | "obsidian-brain" | "memory-simple" | "none";
+export type HookProfile = "minimal" | "standard" | "strict";
 export interface InitOptions {
     projectName: string;
     projectDir: string;
@@ -11,12 +12,32 @@ export interface InitOptions {
     sdd: boolean;
     ghagga: boolean;
     mock: boolean;
+    contextDir: boolean;
+    claudeMd: boolean;
+    securityHooks: boolean;
+    hookProfile: HookProfile;
+    codeGraph: boolean;
+    dockerDeploy: boolean;
+    /** Service name for docker rollout (default: 'app') */
+    dockerServiceName: string;
+    /** Scaffold local AI dev stack (Ollama + optional services) */
+    localAi: boolean;
     dryRun: boolean;
 }
+export interface StackClaudeMdEntry {
+    skills: string[];
+    conventions: string;
+    testFramework: string;
+}
+export interface StackContextEntry {
+    tree: string;
+    conventions: string;
+    entryPoint: string;
+}
 export interface InitStep {
     id: string;
     label: string;
-    status: 'pending' | 'running' | 'done' | 'error' | 'skipped';
+    status: "pending" | "running" | "done" | "error" | "skipped";
     detail?: string;
 }
 export interface StackDetection {
@@ -36,7 +57,7 @@ export interface ForgeManifest {
 }
 export interface DoctorCheck {
     label: string;
-    status: 'ok' | 'fail' | 'skip';
+    status: "ok" | "fail" | "skip";
     detail?: string;
 }
 export interface DoctorSection {
@@ -46,6 +67,13 @@ export interface DoctorSection {
 export interface DoctorResult {
     sections: DoctorSection[];
 }
+export type TddPipelineMode = "strict" | "warn";
+export interface TddPipelineResult {
+    installed: string[];
+    skipped: string[];
+    errors: string[];
+    mode: TddPipelineMode;
+}
 export interface PluginManifest {
     name: string;
     version: string;
@@ -87,4 +115,223 @@ export interface InstalledPlugin {
     source: string;
     manifest: PluginManifest;
 }
+export interface PluginSyncResult {
+    added: string[];
+    removed: string[];
+    unchanged: string[];
+    wired: AutoWireEntry[];
+    unwired: AutoWireEntry[];
+}
+export type AutoWireTarget = "claude-md" | "settings-json";
+export interface AutoWireEntry {
+    plugin: string;
+    target: AutoWireTarget;
+    capability: string;
+    /** e.g. skill path or hook command */
+    value: string;
+}
+export interface AutoWireResult {
+    wired: AutoWireEntry[];
+    unwired: AutoWireEntry[];
+    errors: string[];
+}
+export interface AgentSkillEntry {
+    name: string;
+    description: string;
+    path: string;
+}
+export interface AgentSkillsManifest {
+    name: string;
+    version: string;
+    description: string;
+    skills: AgentSkillEntry[];
+    metadata?: {
+        forge_source?: string;
+    };
+}
+/**
+ * Aggregated skills.json that merges multiple plugins into a single
+ * Agent Skills spec manifest. Used by `npx skills add` and 40+ AI agents.
+ */
+export interface AggregatedSkillsManifest {
+    name: string;
+    version: string;
+    description: string;
+    skills: AgentSkillEntry[];
+    sources: AgentSkillSource[];
+}
+export interface AgentSkillSource {
+    plugin: string;
+    version: string;
+    repository?: string;
+}
+export interface CodexTomlEntry {
+    name: string;
+    model: string;
+    instructions: string;
+}
+export interface CodexExportResult {
+    success: boolean;
+    files?: string[];
+    error?: string;
+}
+export type SecuritySeverity = "critical" | "high" | "moderate" | "low" | "info";
+export interface SecurityFinding {
+    id: string;
+    severity: SecuritySeverity;
+    package: string;
+    title: string;
+    url?: string;
+}
+export interface SecurityBaseline {
+    version: string;
+    createdAt: string;
+    updatedAt?: string;
+    stack: string;
+    buildTool: string;
+    findings: SecurityFinding[];
+    findingKeys: string[];
+    allowlist?: string[];
+}
+export interface SecurityCheckOptions {
+    minSeverity?: SecuritySeverity;
+    staleDays?: number;
+}
+export interface SecurityCheckResult {
+    baseline: SecurityBaseline;
+    current: SecurityFinding[];
+    regressions: SecurityFinding[];
+    resolved: SecurityFinding[];
+    filteredRegressions: SecurityFinding[];
+    staleWarning?: string;
+    summary: SecuritySummary;
+}
+export interface SecuritySummary {
+    total: number;
+    bySeverity: Record<SecuritySeverity, number>;
+    regressionCount: number;
+    resolvedCount: number;
+    filteredCount: number;
+    baselineAge: number;
+}
+export interface SkillCriticalRule {
+    skillName: string;
+    skillPath: string;
+    rule: string;
+    /** Normalized rule for comparison (lowercase, trimmed) */
+    normalized: string;
+}
+export type ConflictKind = "regex-pair" | "directive-clash";
+export interface SkillConflict {
+    ruleA: SkillCriticalRule;
+    ruleB: SkillCriticalRule;
+    reason: string;
+    /** How the conflict was detected */
+    kind: ConflictKind;
+}
+export interface SkillBudgetEntry {
+    skillName: string;
+    skillPath: string;
+    tokens: number;
+}
+export interface SkillBudgetSuggestion {
+    /** Skills to disable in this suggestion set */
+    disableSkills: string[];
+    /** Total tokens freed by disabling these skills */
+    tokensSaved: number;
+    /** Remaining tokens after disabling */
+    remainingTokens: number;
+    /** Whether this set brings usage under budget */
+    meetsbudget: boolean;
+}
+export interface SkillBudgetResult {
+    entries: SkillBudgetEntry[];
+    totalTokens: number;
+    budget: number;
+    overBudget: boolean;
+    suggestions: string[];
+    /** Structured optimization sets: minimal combinations to meet budget */
+    optimizations: SkillBudgetSuggestion[];
+}
+export interface SkillDuplicate {
+    skillA: string;
+    skillB: string;
+    /** Overlapping trigger keywords */
+    sharedTriggers: string[];
+    similarity: number;
+}
+export interface SkillDoctorResult {
+    conflicts: SkillConflict[];
+    budget: SkillBudgetResult;
+    duplicates: SkillDuplicate[];
+}
+export type SkillGrade = "A" | "B" | "C" | "D" | "F";
+export interface SkillScore {
+    skillName: string;
+    completeness: number;
+    clarity: number;
+    testability: number;
+    tokenEfficiency: number;
+    safety: number;
+    agentReadiness: number;
+    overall: number;
+    grade: SkillGrade;
+    threshold: number;
+    passing: boolean;
+}
+export interface SkillRegistryGateResult {
+    skillName: string;
+    score: SkillScore;
+    accepted: boolean;
+    reason?: string;
+}
+export interface SkillBenchmarkCheck {
+    name: string;
+    passed: boolean;
+    detail?: string;
+}
+export interface SkillBenchmarkResult {
+    skillName: string;
+    checks: SkillBenchmarkCheck[];
+    passRate: number;
+}
+declare const WORKFLOW_FORMAT: {
+    readonly DOT: "dot";
+    readonly MERMAID: "mermaid";
+};
+export type WorkflowFormat = (typeof WORKFLOW_FORMAT)[keyof typeof WORKFLOW_FORMAT];
+declare const WORKFLOW_VALIDATION_STATUS: {
+    readonly PASS: "pass";
+    readonly FAIL: "fail";
+    readonly SKIP: "skip";
+};
+export type WorkflowValidationStatus = (typeof WORKFLOW_VALIDATION_STATUS)[keyof typeof WORKFLOW_VALIDATION_STATUS];
+export { WORKFLOW_FORMAT, WORKFLOW_VALIDATION_STATUS };
+export interface WorkflowNode {
+    id: string;
+    label: string;
+    check?: string;
+    metadata?: Record<string, string>;
+}
+export interface WorkflowEdge {
+    from: string;
+    to: string;
+    label?: string;
+}
+export interface WorkflowGraph {
+    name: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    format: WorkflowFormat;
+}
+export interface WorkflowValidationResult {
+    node: string;
+    status: WorkflowValidationStatus;
+    detail?: string;
+}
+export interface WorkflowDiscoveryEntry {
+    name: string;
+    path: string;
+    format: WorkflowFormat;
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,2 +1,12 @@
-export {};
+// ── Workflow Graphs ─────────────────────────────────────────────────────────
+const WORKFLOW_FORMAT = {
+    DOT: "dot",
+    MERMAID: "mermaid",
+};
+const WORKFLOW_VALIDATION_STATUS = {
+    PASS: "pass",
+    FAIL: "fail",
+    SKIP: "skip",
+};
+export { WORKFLOW_FORMAT, WORKFLOW_VALIDATION_STATUS };
 //# sourceMappingURL=index.js.map

package/dist/ui/AnalyzeUI.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React from "react";
 interface Props {
     dryRun: boolean;
 }

package/dist/ui/AnalyzeUI.js

@@ -1,10 +1,10 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text, useApp, useInput } from 'ink';
-import Spinner from 'ink-spinner';
-import { runAnalyze } from '../commands/analyze.js';
-import Header from './Header.js';
-import { theme } from './theme.js';
-import { useCIMode } from './CIContext.js';
+import { Box, Text, useApp, useInput } from "ink";
+import Spinner from "ink-spinner";
+import React, { useEffect, useState } from "react";
+import { runAnalyze } from "../commands/analyze.js";
+import { useCIMode } from "./CIContext.js";
+import Header from "./Header.js";
+import { theme } from "./theme.js";
 export default function AnalyzeUI({ dryRun }) {
     const { exit } = useApp();
     const isCI = useCIMode();
@@ -12,8 +12,8 @@ export default function AnalyzeUI({ dryRun }) {
     const [finished, setFinished] = useState(false);
     const [startTime] = useState(Date.now());
     useEffect(() => {
-        runAnalyze(process.cwd(), dryRun, (step) => setSteps(prev => {
-            const idx = prev.findIndex(s => s.id === step.id);
+        runAnalyze(process.cwd(), dryRun, (step) => setSteps((prev) => {
+            const idx = prev.findIndex((s) => s.id === step.id);
             if (idx >= 0) {
                 const next = [...prev];
                 next[idx] = step;
@@ -34,9 +34,9 @@ export default function AnalyzeUI({ dryRun }) {
         if (finished && (key.return || key.escape))
             exit();
     }, { isActive: !isCI });
-    const doneCount = steps.filter(s => s.status === 'done').length;
-    const errorCount = steps.filter(s => s.status === 'error').length;
-    const notInstalled = steps.some(s => s.status === 'error' && s.detail?.includes('not found'));
+    const doneCount = steps.filter((s) => s.status === "done").length;
+    const errorCount = steps.filter((s) => s.status === "error").length;
+    const notInstalled = steps.some((s) => s.status === "error" && s.detail?.includes("not found"));
     const elapsed = finished
         ? `${((Date.now() - startTime) / 1000).toFixed(1)}s`
         : null;
@@ -45,52 +45,51 @@ export default function AnalyzeUI({ dryRun }) {
         !finished && steps.length === 0 && (React.createElement(Box, { marginLeft: 2 },
             React.createElement(Text, { color: theme.warning },
                 React.createElement(Spinner, { type: "dots" }),
-                ' ',
-                "Checking for repoforge..."))),
-        React.createElement(Box, { flexDirection: "column" }, steps.map(step => (React.createElement(Box, { key: step.id, marginLeft: 2 }, step.status === 'running' ? (React.createElement(Text, { color: theme.warning },
+                " Checking for repoforge..."))),
+        React.createElement(Box, { flexDirection: "column" }, steps.map((step) => (React.createElement(Box, { key: step.id, marginLeft: 2 }, step.status === "running" ? (React.createElement(Text, { color: theme.warning },
             React.createElement(Spinner, { type: "dots" }),
-            ' ',
-            step.label)) : step.status === 'done' ? (React.createElement(Text, { color: theme.success },
-            '\u2713',
+            " ",
+            step.label)) : step.status === "done" ? (React.createElement(Text, { color: theme.success },
+            "\u2713",
             " ",
             step.label,
-            step.detail && React.createElement(Text, { color: theme.muted, dimColor: true },
-                "  ",
-                step.detail))) : step.status === 'error' ? (React.createElement(Text, { color: theme.error },
-            '\u2717',
+            step.detail && (React.createElement(Text, { color: theme.muted, dimColor: true },
+                " ",
+                step.detail)))) : step.status === "error" ? (React.createElement(Text, { color: theme.error },
+            "\u2717",
             " ",
             step.label,
-            step.detail && React.createElement(Text, { color: theme.muted, dimColor: true },
-                "  ",
-                step.detail))) : (React.createElement(Text, { color: theme.muted },
-            '\u2013',
+            step.detail && (React.createElement(Text, { color: theme.muted, dimColor: true },
+                " ",
+                step.detail)))) : (React.createElement(Text, { color: theme.muted },
+            "\u2013",
             " ",
             step.label,
             step.detail && React.createElement(Text, { dimColor: true },
-                "  ",
+                " ",
                 step.detail))))))),
         finished && notInstalled && (React.createElement(Box, { marginTop: 1, flexDirection: "column", marginLeft: 2 },
             React.createElement(Text, { color: theme.warning, bold: true }, "repoforge is not installed"),
             React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, { color: theme.muted }, "  Install it with:"),
-                React.createElement(Text, { color: theme.primary }, "    pip install repoforge"),
-                React.createElement(Text, { color: theme.muted }, "  Then run:"),
-                React.createElement(Text, { color: theme.primary }, "    javi-forge analyze")))),
+                React.createElement(Text, { color: theme.muted }, " Install it with:"),
+                React.createElement(Text, { color: theme.primary }, " pip install repoforge"),
+                React.createElement(Text, { color: theme.muted }, " Then run:"),
+                React.createElement(Text, { color: theme.primary }, " javi-forge analyze")))),
         finished && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
             React.createElement(Text, { bold: true, color: errorCount > 0 ? theme.warning : theme.success },
-                dryRun ? '\u25cb Dry run complete' : '\u2713 Analysis complete',
-                elapsed && React.createElement(Text, { color: theme.muted },
-                    "  Completed in ",
-                    elapsed)),
+                dryRun ? "\u25cb Dry run complete" : "\u2713 Analysis complete",
+                elapsed && (React.createElement(Text, { color: theme.muted },
+                    " Completed in ",
+                    elapsed))),
             doneCount > 0 && (React.createElement(Text, { color: theme.success },
-                "  ",
-                '\u2713',
+                " ",
+                "\u2713",
                 " ",
                 doneCount,
                 " checks passed")),
             errorCount > 0 && (React.createElement(Text, { color: theme.error },
-                "  ",
-                '\u2717',
+                " ",
+                "\u2717",
                 " ",
                 errorCount,
                 " errors")),

package/dist/ui/App.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
-import type { Stack, CIProvider, MemoryOption } from '../types/index.js';
+import React from "react";
+import type { CIProvider, HookProfile, MemoryOption, Stack } from "../types/index.js";
 interface AppProps {
     dryRun?: boolean;
     presetStack?: Stack;
@@ -8,7 +8,9 @@ interface AppProps {
     presetName?: string;
     presetGhagga?: boolean;
     presetMock?: boolean;
+    presetLocalAi?: boolean;
+    presetHookProfile?: HookProfile;
 }
-export default function App({ dryRun, presetStack, presetCI, presetMemory, presetName, presetGhagga, presetMock, }: AppProps): React.JSX.Element;
+export default function App({ dryRun, presetStack, presetCI, presetMemory, presetName, presetGhagga, presetMock, presetLocalAi, presetHookProfile, }: AppProps): React.JSX.Element;
 export {};
 //# sourceMappingURL=App.d.ts.map

package/dist/ui/App.js

@@ -1,50 +1,85 @@
-import React, { useState } from 'react';
-import { Box } from 'ink';
-import path from 'path';
-import Welcome from './Welcome.js';
-import Header from './Header.js';
-import NameInput from './NameInput.js';
-import StackSelector from './StackSelector.js';
-import CISelector from './CISelector.js';
-import MemorySelector from './MemorySelector.js';
-import OptionSelector from './OptionSelector.js';
-import Progress from './Progress.js';
-import Summary from './Summary.js';
-import { initProject } from '../commands/init.js';
-export default function App({ dryRun = false, presetStack, presetCI, presetMemory, presetName, presetGhagga = false, presetMock = false, }) {
-    const [stage, setStage] = useState('welcome');
-    const [projectName, setProjectName] = useState(presetName ?? '');
-    const [projectDir, setProjectDir] = useState(presetName ? path.resolve(process.cwd(), presetName) : '');
-    const [stack, setStack] = useState(presetStack ?? 'node');
-    const [ciProvider, setCIProvider] = useState(presetCI ?? 'github');
-    const [memory, setMemory] = useState(presetMemory ?? 'engram');
+import { Box } from "ink";
+import path from "path";
+import React, { useState } from "react";
+import { initProject } from "../commands/init.js";
+import CISelector from "./CISelector.js";
+import Header from "./Header.js";
+import HookProfileSelector from "./HookProfileSelector.js";
+import MemorySelector from "./MemorySelector.js";
+import NameInput from "./NameInput.js";
+import OptionSelector from "./OptionSelector.js";
+import Progress from "./Progress.js";
+import StackSelector from "./StackSelector.js";
+import Summary from "./Summary.js";
+import Welcome from "./Welcome.js";
+export default function App({ dryRun = false, presetStack, presetCI, presetMemory, presetName, presetGhagga = false, presetMock = false, presetLocalAi = false, presetHookProfile, }) {
+    const [stage, setStage] = useState("welcome");
+    const [projectName, setProjectName] = useState(presetName ?? "");
+    const [projectDir, setProjectDir] = useState(presetName ? path.resolve(process.cwd(), presetName) : "");
+    const [stack, setStack] = useState(presetStack ?? "node");
+    const [ciProvider, setCIProvider] = useState(presetCI ?? "github");
+    const [memory, setMemory] = useState(presetMemory ?? "engram");
     const [aiSync, setAiSync] = useState(true);
     const [sdd, setSdd] = useState(true);
+    const [contextDir, setContextDir] = useState(true);
+    const [claudeMd, setClaudeMd] = useState(true);
     const [ghagga, setGhagga] = useState(presetGhagga);
+    const [securityHooks, setSecurityHooks] = useState(true);
+    const [hookProfile, setHookProfile] = useState(presetHookProfile ?? "standard");
+    const [codeGraph, setCodeGraph] = useState(false);
+    const [localAi, setLocalAi] = useState(false);
     const [steps, setSteps] = useState([]);
     const [startTime] = useState(Date.now());
     const handleNameConfirm = (name, dir) => {
         setProjectName(name);
         setProjectDir(dir);
-        setStage(presetStack ? 'ci' : 'stack');
+        setStage(presetStack ? "ci" : "stack");
     };
     const handleStackConfirm = (s) => {
         setStack(s);
-        setStage(presetCI ? 'memory' : 'ci');
+        setStage(presetCI ? "memory" : "ci");
     };
     const handleCIConfirm = (p) => {
         setCIProvider(p);
-        setStage(presetMemory ? 'options' : 'memory');
+        setStage(presetMemory ? "options" : "memory");
     };
     const handleMemoryConfirm = (m) => {
         setMemory(m);
-        setStage('options');
+        setStage("options");
     };
-    const handleOptionsConfirm = async (opts) => {
+    const handleOptionsConfirm = (opts) => {
         setAiSync(opts.aiSync);
         setSdd(opts.sdd);
+        setContextDir(opts.contextDir);
+        setClaudeMd(opts.claudeMd);
         setGhagga(opts.ghagga);
-        setStage('running');
+        setSecurityHooks(opts.securityHooks);
+        setCodeGraph(opts.codeGraph);
+        setLocalAi(opts.localAi);
+        // If securityHooks is selected, ask for profile; otherwise skip to running
+        if (opts.securityHooks) {
+            setStage("hook-profile");
+        }
+        else {
+            void runInit({ ...opts, hookProfile });
+        }
+    };
+    const handleHookProfileConfirm = (profile) => {
+        setHookProfile(profile);
+        void runInit({
+            aiSync,
+            sdd,
+            contextDir,
+            claudeMd,
+            ghagga,
+            securityHooks,
+            codeGraph,
+            localAi,
+            hookProfile: profile,
+        });
+    };
+    const runInit = async (opts) => {
+        setStage("running");
         await initProject({
             projectName,
             projectDir,
@@ -54,10 +89,18 @@ export default function App({ dryRun = false, presetStack, presetCI, presetMemor
             aiSync: opts.aiSync,
             sdd: opts.sdd,
             ghagga: opts.ghagga,
+            contextDir: opts.contextDir,
+            claudeMd: opts.claudeMd,
+            securityHooks: opts.securityHooks,
+            hookProfile: opts.hookProfile,
+            codeGraph: opts.codeGraph,
+            localAi: opts.localAi,
+            dockerDeploy: false,
+            dockerServiceName: "app",
             mock: presetMock,
             dryRun,
-        }, (step) => setSteps(prev => {
-            const idx = prev.findIndex(s => s.id === step.id);
+        }, (step) => setSteps((prev) => {
+            const idx = prev.findIndex((s) => s.id === step.id);
             if (idx >= 0) {
                 const next = [...prev];
                 next[idx] = step;
@@ -65,37 +108,40 @@ export default function App({ dryRun = false, presetStack, presetCI, presetMemor
             }
             return [...prev, step];
         }));
-        setStage('done');
+        setStage("done");
     };
-    const subtitle = stage === 'running' ? 'scaffolding...' :
-        stage === 'done' ? 'complete' :
-            undefined;
+    const subtitle = stage === "running"
+        ? "scaffolding..."
+        : stage === "done"
+            ? "complete"
+            : undefined;
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        stage !== 'welcome' && React.createElement(Header, { subtitle: subtitle, dryRun: dryRun }),
-        stage === 'welcome' && (React.createElement(Welcome, { onDone: () => {
+        stage !== "welcome" && React.createElement(Header, { subtitle: subtitle, dryRun: dryRun }),
+        stage === "welcome" && (React.createElement(Welcome, { onDone: () => {
                 // Skip stages for which presets are already provided
                 if (presetName && presetStack && presetCI && presetMemory) {
-                    setStage('options');
+                    setStage("options");
                 }
                 else if (presetName && presetStack && presetCI) {
-                    setStage('memory');
+                    setStage("memory");
                 }
                 else if (presetName && presetStack) {
-                    setStage('ci');
+                    setStage("ci");
                 }
                 else if (presetName) {
-                    setStage('stack');
+                    setStage("stack");
                 }
                 else {
-                    setStage('name');
+                    setStage("name");
                 }
             } })),
-        stage === 'name' && (React.createElement(NameInput, { defaultName: projectName || 'my-project', onConfirm: handleNameConfirm })),
-        stage === 'stack' && (React.createElement(StackSelector, { projectDir: projectDir || process.cwd(), onConfirm: handleStackConfirm })),
-        stage === 'ci' && (React.createElement(CISelector, { onConfirm: handleCIConfirm })),
-        stage === 'memory' && (React.createElement(MemorySelector, { onConfirm: handleMemoryConfirm })),
-        stage === 'options' && (React.createElement(OptionSelector, { onConfirm: handleOptionsConfirm, presetGhagga: presetGhagga })),
-        stage === 'running' && (React.createElement(Progress, { steps: steps, projectName: projectName, contextLine: `${projectName} (${stack} + ${ciProvider})`, onDone: () => setStage('done') })),
-        stage === 'done' && (React.createElement(Summary, { steps: steps, dryRun: dryRun, projectName: projectName, stack: stack, elapsedMs: Date.now() - startTime }))));
+        stage === "name" && (React.createElement(NameInput, { defaultName: projectName || "my-project", onConfirm: handleNameConfirm })),
+        stage === "stack" && (React.createElement(StackSelector, { projectDir: projectDir || process.cwd(), onConfirm: handleStackConfirm })),
+        stage === "ci" && React.createElement(CISelector, { onConfirm: handleCIConfirm }),
+        stage === "memory" && React.createElement(MemorySelector, { onConfirm: handleMemoryConfirm }),
+        stage === "options" && (React.createElement(OptionSelector, { onConfirm: handleOptionsConfirm, presetGhagga: presetGhagga, presetLocalAi: presetLocalAi })),
+        stage === "hook-profile" && (React.createElement(HookProfileSelector, { onConfirm: handleHookProfileConfirm, presetProfile: presetHookProfile })),
+        stage === "running" && (React.createElement(Progress, { steps: steps, projectName: projectName, contextLine: `${projectName} (${stack} + ${ciProvider})`, onDone: () => setStage("done") })),
+        stage === "done" && (React.createElement(Summary, { steps: steps, dryRun: dryRun, projectName: projectName, stack: stack, elapsedMs: Date.now() - startTime }))));
 }
 //# sourceMappingURL=App.js.map

package/dist/ui/AutoSkills.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface AutoSkillsProps {
+    projectDir: string;
+    skillsDir?: string;
+    dryRun?: boolean;
+}
+export default function AutoSkills({ projectDir, skillsDir, dryRun, }: AutoSkillsProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=AutoSkills.d.ts.map