keating 0.3.6

package/dist/src/cli/main.js

@@ -0,0 +1,357 @@
+import { access } from "node:fs/promises";
+import { relative } from "node:path";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { DEFAULT_KEATING_CONFIG, configPath, loadKeatingConfig, writeKeatingConfig } from "../core/config.js";
+import { learnerStatePath } from "../core/paths.js";
+import { loadLearnerState, recordFeedback, saveLearnerState } from "../core/learner-state.js";
+import { animateTopicArtifact, autoImproveArtifact, benchPolicyArtifact, promptEvalArtifact, currentPolicySummary, ensureProjectScaffold, evolvePolicyArtifact, evolvePromptArtifact, improveArtifact, improveHistory, listArtifacts, mapTopicArtifact, planTopicArtifact, quizTopicArtifact, verifyTopicArtifact, timelineArtifact, dueTopicsArtifact } from "../core/project.js";
+import { detectAiRuntime, launchShell } from "../runtime/pi.js";
+import { serveWeb } from "./web.js";
+import { color, bold, cliCommands } from "../core/theme.js";
+import { printAsciiHeader } from "../core/terminal.js";
+function printUsage() {
+    printAsciiHeader();
+    console.log(bold("primary", "Keating CLI") + "  " + color.dim + color.sepia + "v0.3.6" + color.reset);
+    console.log(color.parchment + "The Hyperteacher — cognitive empowerment through Socratic AI." + color.reset);
+    console.log("");
+    console.log(cliCommands());
+    console.log("");
+    console.log(bold("primary", "General Commands"));
+    console.log(`  ${color.primary}shell${color.reset}  [initial prompt...]  Launch the AI-powered hyperteacher shell`);
+    console.log(`  ${color.primary}setup${color.reset}  [--yes]             Configure Keating for this project`);
+    console.log(`  ${color.primary}doctor${color.reset}                    Inspect AI runtime and oxdraw availability`);
+    console.log(`  ${color.primary}web${color.reset}     [port]             Start a local server for the browser UI`);
+    console.log(`  ${color.primary}policy${color.reset}                    Print the active teaching policy`);
+    console.log(`  ${color.primary}trace${color.reset}   [substring]        Browse debug traces and artifacts`);
+    console.log("");
+}
+function normalizeTopLevelShellArgs(args) {
+    if (args.length === 0 || !args[0]?.startsWith("-") || args[0] === "--help" || args[0] === "-h")
+        return null;
+    return args.map((arg) => arg === "--list-model" ? "--list-models" : arg);
+}
+function commandUsage(command, example) {
+    return new Error([
+        `${command} needs more input.`,
+        "",
+        "Recover with:",
+        `  ${example}`,
+        "  keating help"
+    ].join("\n"));
+}
+function unknownCommand(command) {
+    return new Error([
+        `Unknown command: ${command}`,
+        "",
+        "Recover with:",
+        "  keating help",
+        "  keating setup",
+        "  keating shell",
+        "",
+        "For model discovery, use:",
+        "  keating --list-models"
+    ].join("\n"));
+}
+async function setupProject(cwd, args) {
+    const yes = args.includes("--yes") || args.includes("-y");
+    const existing = await loadKeatingConfig(cwd);
+    let next = {
+        ...DEFAULT_KEATING_CONFIG,
+        ...existing,
+        pi: {
+            ...DEFAULT_KEATING_CONFIG.pi,
+            ...existing.pi
+        },
+        speech: {
+            ...DEFAULT_KEATING_CONFIG.speech,
+            ...existing.speech
+        },
+        debug: {
+            ...DEFAULT_KEATING_CONFIG.debug,
+            ...existing.debug
+        }
+    };
+    if (!yes && process.stdin.isTTY && process.stdout.isTTY) {
+        const { runInteractiveSetup } = await import("./setup.js");
+        const answers = await runInteractiveSetup({
+            runtimePreference: next.pi.runtimePreference,
+            defaultProvider: next.pi.defaultProvider ?? "google",
+            defaultModel: next.pi.defaultModel ?? "gemini-3.1-pro-preview",
+            defaultThinking: next.pi.defaultThinking ?? "medium"
+        });
+        if (!answers) {
+            console.log(`${color.sepia}Setup cancelled.${color.reset}`);
+            return;
+        }
+        next = {
+            ...next,
+            pi: {
+                ...next.pi,
+                ...answers
+            }
+        };
+    }
+    else {
+        next = {
+            ...next,
+            pi: {
+                ...next.pi,
+                runtimePreference: DEFAULT_KEATING_CONFIG.pi.runtimePreference,
+                defaultProvider: DEFAULT_KEATING_CONFIG.pi.defaultProvider,
+                defaultModel: DEFAULT_KEATING_CONFIG.pi.defaultModel,
+                defaultThinking: DEFAULT_KEATING_CONFIG.pi.defaultThinking
+            }
+        };
+    }
+    await writeKeatingConfig(cwd, next);
+    console.log(`${color.ok}Wrote ${relative(cwd, configPath(cwd))}${color.reset}`);
+    console.log(`Run ${color.primary}keating doctor${color.reset} to verify the runtime, then ${color.primary}keating shell${color.reset}.`);
+}
+async function run() {
+    const rawArgs = process.argv.slice(2);
+    const cwd = process.cwd();
+    const topLevelShellArgs = normalizeTopLevelShellArgs(rawArgs);
+    if (topLevelShellArgs) {
+        const exitCode = await launchShell(cwd, topLevelShellArgs);
+        process.exitCode = exitCode;
+        return;
+    }
+    const [command = "shell", ...args] = rawArgs;
+    switch (command) {
+        case "setup": {
+            await setupProject(cwd, args);
+            return;
+        }
+        case "web": {
+            const port = args[0] ? parseInt(args[0], 10) : 3000;
+            await serveWeb(port);
+            return;
+        }
+        case "shell": {
+            const exitCode = await launchShell(cwd, args);
+            process.exitCode = exitCode;
+            return;
+        }
+        case "plan": {
+            const topic = args.join(" ").trim();
+            if (!topic)
+                throw commandUsage("plan", "keating plan derivative");
+            const artifact = await planTopicArtifact(cwd, topic);
+            console.log(relative(cwd, artifact.planPath));
+            return;
+        }
+        case "map": {
+            const topic = args.join(" ").trim();
+            if (!topic)
+                throw commandUsage("map", "keating map derivative");
+            const artifact = await mapTopicArtifact(cwd, topic);
+            console.log(relative(cwd, artifact.mmdPath));
+            if (artifact.svgPath)
+                console.log(relative(cwd, artifact.svgPath));
+            return;
+        }
+        case "animate": {
+            const topic = args.join(" ").trim();
+            if (!topic)
+                throw commandUsage("animate", "keating animate derivative");
+            const artifact = await animateTopicArtifact(cwd, topic);
+            console.log(relative(cwd, artifact.playerPath));
+            console.log(relative(cwd, artifact.scenePath));
+            console.log(relative(cwd, artifact.storyboardPath));
+            console.log(relative(cwd, artifact.manifestPath));
+            return;
+        }
+        case "verify": {
+            const topic = args.join(" ").trim();
+            if (!topic)
+                throw commandUsage("verify", "keating verify derivative");
+            const result = await verifyTopicArtifact(cwd, topic);
+            if (result.alreadyVerified) {
+                console.log(`Already verified: ${relative(cwd, result.checklistPath)}`);
+            }
+            else {
+                console.log(`Verification checklist: ${relative(cwd, result.checklistPath)}`);
+            }
+            return;
+        }
+        case "quiz": {
+            const topic = args.join(" ").trim();
+            if (!topic)
+                throw commandUsage("quiz", "keating quiz derivative");
+            const result = await quizTopicArtifact(cwd, topic);
+            console.log(relative(cwd, result.quizPath));
+            console.log(relative(cwd, result.answersPath));
+            return;
+        }
+        case "bench": {
+            const topic = args.join(" ").trim() || undefined;
+            const result = await benchPolicyArtifact(cwd, topic);
+            console.log(`${result.overallScore.toFixed(2)} ${relative(cwd, result.reportPath)}`);
+            if (result.tracePath)
+                console.log(relative(cwd, result.tracePath));
+            return;
+        }
+        case "evolve": {
+            const topic = args.join(" ").trim() || undefined;
+            const result = await evolvePolicyArtifact(cwd, topic);
+            console.log(`${result.bestScore.toFixed(2)} ${relative(cwd, result.reportPath)}`);
+            if (result.tracePath)
+                console.log(relative(cwd, result.tracePath));
+            return;
+        }
+        case "prompt-evolve": {
+            const promptName = args.join(" ").trim() || "learn";
+            const result = await evolvePromptArtifact(cwd, promptName);
+            console.log(`${result.bestScore.toFixed(2)} ${relative(cwd, result.reportPath)}`);
+            console.log(relative(cwd, result.evolvedPromptPath));
+            return;
+        }
+        case "prompt-eval": {
+            const promptContent = args.join(" ").trim();
+            if (!promptContent)
+                throw commandUsage("prompt-eval", "keating prompt-eval \"Start with a diagnostic question.\"");
+            const result = await promptEvalArtifact(cwd, promptContent);
+            console.log(`${result.score.toFixed(2)} ${relative(cwd, result.reportPath)}`);
+            return;
+        }
+        case "improve": {
+            if (args[0] === "history") {
+                const md = await improveHistory(cwd);
+                console.log(md);
+                return;
+            }
+            const artifact = await improveArtifact(cwd);
+            console.log(`Proposal: ${artifact.proposal.id}`);
+            console.log(`Targets: ${artifact.proposal.targets.map(t => t.file).join(", ")}`);
+            console.log(relative(cwd, artifact.proposalPath));
+            return;
+        }
+        case "auto-improve": {
+            const topic = args.join(" ").trim() || undefined;
+            const result = await autoImproveArtifact(cwd, topic);
+            const verdict = result.delta > 0
+                ? `${color.ok}IMPROVED by +${result.delta.toFixed(2)}${color.reset}`
+                : result.delta < -0.5
+                    ? `${color.err}REGRESSED by ${result.delta.toFixed(2)}${color.reset}`
+                    : `${color.sepia}NO SIGNIFICANT CHANGE (Δ${result.delta.toFixed(2)})${color.reset}`;
+            console.log(`Baseline: ${result.baselineScore.toFixed(2)} → After: ${result.afterScore.toFixed(2)} — ${verdict}`);
+            console.log(relative(cwd, result.reportPath));
+            return;
+        }
+        case "policy": {
+            await ensureProjectScaffold(cwd);
+            console.log(await currentPolicySummary(cwd));
+            return;
+        }
+        case "trace": {
+            await ensureProjectScaffold(cwd);
+            const query = args.join(" ").trim().toLowerCase();
+            const artifacts = await listArtifacts(cwd);
+            for (const artifact of artifacts) {
+                if (!query || artifact.path.toLowerCase().includes(query) || artifact.label.toLowerCase().includes(query)) {
+                    console.log(artifact.path);
+                }
+            }
+            return;
+        }
+        case "learner-state": {
+            await ensureProjectScaffold(cwd);
+            const statePath = learnerStatePath(cwd);
+            const state = await loadLearnerState(statePath);
+            const upCount = state.feedback.filter((f) => f.signal === "thumbs-up").length;
+            const downCount = state.feedback.filter((f) => f.signal === "thumbs-down").length;
+            const confusedCount = state.feedback.filter((f) => f.signal === "confused").length;
+            console.log(`${bold("primary", "Learner Profile")}`);
+            console.log(`  Sessions: ${state.sessions?.length ?? 0}`);
+            console.log(`  Topics covered: ${state.coveredTopics.length}`);
+            for (const t of state.coveredTopics.slice(-10))
+                console.log(`    - ${t.slug} (${t.domain})`);
+            console.log(`  Feedback: 👍${upCount} 👎${downCount} 🤔${confusedCount}`);
+            console.log(`  Misconceptions identified: ${state.identifiedMisconceptions.length}`);
+            return;
+        }
+        case "timeline": {
+            const { markdown } = await timelineArtifact(cwd);
+            console.log(markdown);
+            return;
+        }
+        case "due": {
+            const { markdown } = await dueTopicsArtifact(cwd);
+            console.log(markdown);
+            return;
+        }
+        case "feedback": {
+            const signalMap = {
+                up: "thumbs-up",
+                down: "thumbs-down",
+                confused: "confused"
+            };
+            const signal = signalMap[args[0]?.toLowerCase() ?? ""];
+            if (!signal) {
+                throw new Error([
+                    "feedback needs a signal: up, down, or confused.",
+                    "",
+                    "Recover with:",
+                    "  keating feedback up derivative",
+                    "  keating feedback confused derivative --comment=\"lost at chain rule\""
+                ].join("\n"));
+            }
+            let comment;
+            const filtered = args.filter((arg) => {
+                if (arg.startsWith("--comment=")) {
+                    comment = arg.slice("--comment=".length);
+                    return false;
+                }
+                return true;
+            });
+            const topic = filtered.slice(1).join(" ") || "general";
+            const statePath = learnerStatePath(cwd);
+            const state = await loadLearnerState(statePath);
+            recordFeedback(state, topic, signal, comment);
+            await saveLearnerState(statePath, state);
+            const sigLabel = { "thumbs-up": "👍 up", "thumbs-down": "👎 down", "confused": "🤔 confused" }[signal];
+            const commentHint = comment ? ` (comment: "${comment}")` : "";
+            console.log(`${color.ok}Recorded ${sigLabel} feedback for "${topic}"${commentHint}.${color.reset}`);
+            return;
+        }
+        case "doctor": {
+            await ensureProjectScaffold(cwd);
+            const config = await loadKeatingConfig(cwd);
+            const runtime = await detectAiRuntime(cwd);
+            const oxdraw = spawnSync("which", ["oxdraw"], { encoding: "utf8" });
+            const manimWebPath = join(cwd, "node_modules", "manim-web", "dist", "index.js");
+            const manimWebInstalled = await access(manimWebPath).then(() => true, () => false);
+            console.log(`${bold("primary", "Keating Doctor")}  ${color.sepia}diagnostic report${color.reset}\n`);
+            console.log(`  ${color.cream}config_path${color.reset}           ${color.sepia}${configPath(cwd)}${color.reset}`);
+            console.log(`  ${color.cream}ai_runtime_preference${color.reset} ${color.primary}${config.pi.runtimePreference}${color.reset}`);
+            console.log(`  ${color.cream}ai_default_provider${color.reset}   ${config.pi.defaultProvider ?? color.sepia + "unset" + color.reset}`);
+            console.log(`  ${color.cream}ai_default_model${color.reset}      ${config.pi.defaultModel ?? color.sepia + "unset" + color.reset}`);
+            console.log(`  ${color.cream}ai_default_thinking${color.reset}   ${config.pi.defaultThinking ?? color.sepia + "unset" + color.reset}`);
+            console.log(`  ${color.cream}debug_persist_traces${color.reset}  ${color.primary}${String(config.debug.persistTraces)}${color.reset}`);
+            console.log(`  ${color.cream}debug_trace_top_learners${color.reset} ${color.primary}${String(config.debug.traceTopLearners)}${color.reset}`);
+            console.log(`  ${color.cream}debug_console_summary${color.reset} ${color.primary}${String(config.debug.consoleSummary)}${color.reset}`);
+            console.log(`  ${color.cream}ai_runtime${color.reset}            ${runtime.selected ? color.ok + runtime.selected.kind : color.err + "missing"}${color.reset}`);
+            console.log(`  ${color.cream}ai_standalone${color.reset}         ${runtime.standalone ? color.primary + runtime.standalone.command : color.err + "missing"}${color.reset}`);
+            console.log(`  ${color.cream}ai_embedded${color.reset}           ${runtime.embedded ? color.primary + (runtime.embedded.cliPath ?? runtime.embedded.command) : color.err + "missing"}${color.reset}`);
+            if (runtime.selected)
+                console.log(`  ${color.cream}ai_command${color.reset}            ${color.primary}${runtime.selected.command}${color.reset}`);
+            console.log(`  ${color.cream}oxdraw${color.reset}                ${oxdraw.status === 0 ? color.ok + oxdraw.stdout.trim() : color.err + "missing"}${color.reset}`);
+            console.log(`  ${color.cream}manim_web${color.reset}             ${manimWebInstalled ? color.ok + manimWebPath : color.err + "missing"}${color.reset}`);
+            return;
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            printUsage();
+            return;
+        }
+        default: {
+            throw unknownCommand(command);
+        }
+    }
+}
+run().catch((error) => {
+    console.error(`${color.err}${color.bold}Error:${color.reset} ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+});

package/dist/src/cli/setup.js

@@ -0,0 +1,197 @@
+import React, { useState } from "react";
+import { Box, Text, render, useApp, useInput } from "ink";
+const PROVIDERS = [
+    { label: "Google", value: "google", hint: "Recommended" },
+    { label: "OpenAI", value: "openai" },
+    { label: "Anthropic", value: "anthropic" },
+    { label: "Custom", value: "custom", hint: "Type a provider name" }
+];
+const MODELS_BY_PROVIDER = {
+    google: [
+        { label: "Gemini 3.1 Pro Preview", value: "gemini-3.1-pro-preview", hint: "Recommended" },
+        { label: "Gemini 3.1 Flash Live Preview", value: "gemini-3.1-flash-live-preview" },
+        { label: "Custom", value: "custom", hint: "Type a model name" }
+    ],
+    openai: [
+        { label: "GPT-5.2", value: "gpt-5.2" },
+        { label: "GPT-5.4", value: "gpt-5.4" },
+        { label: "Custom", value: "custom", hint: "Type a model name" }
+    ],
+    anthropic: [
+        { label: "Claude Sonnet 4.5", value: "claude-sonnet-4-5" },
+        { label: "Custom", value: "custom", hint: "Type a model name" }
+    ],
+    custom: [
+        { label: "Custom", value: "custom", hint: "Type a model name" }
+    ]
+};
+const THINKING = [
+    { label: "Medium", value: "medium", hint: "Recommended" },
+    { label: "Low", value: "low" },
+    { label: "High", value: "high" }
+];
+const RUNTIMES = [
+    { label: "Prefer standalone", value: "prefer-standalone", hint: "Recommended" },
+    { label: "Embedded only", value: "embedded-only" },
+    { label: "Standalone only", value: "standalone-only" }
+];
+function selectedIndex(choices, value) {
+    const index = choices.findIndex((choice) => choice.value === value);
+    return index >= 0 ? index : 0;
+}
+function Menu(props) {
+    useInput((input, key) => {
+        if (key.upArrow)
+            props.setSelected((props.selected - 1 + props.choices.length) % props.choices.length);
+        else if (key.downArrow)
+            props.setSelected((props.selected + 1) % props.choices.length);
+        else if (key.return || input === " ")
+            props.submit();
+    });
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "green", bold: true }, props.title), ...props.choices.map((choice, index) => React.createElement(Text, { key: choice.value, color: index === props.selected ? "green" : undefined }, `${index === props.selected ? ">" : " "} ${choice.label}${choice.hint ? ` - ${choice.hint}` : ""}`)), React.createElement(Text, { dimColor: true }, "Use arrow keys and Enter."));
+}
+function TextPrompt(props) {
+    const [value, setValue] = useState(props.initialValue);
+    useInput((input, key) => {
+        if (key.return)
+            props.submit(value.trim() || props.initialValue);
+        else if (key.backspace || key.delete)
+            setValue((current) => current.slice(0, -1));
+        else if (!key.ctrl && input)
+            setValue((current) => current + input);
+    });
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "green", bold: true }, props.title), React.createElement(Text, null, `> ${value}`), React.createElement(Text, { dimColor: true }, "Type a value and press Enter."));
+}
+function Summary(props) {
+    const choices = [
+        { label: "Write config", value: "yes" },
+        { label: "Go back", value: "back" }
+    ];
+    useInput((input, key) => {
+        if (key.upArrow || key.downArrow)
+            props.setSelected(props.selected === 0 ? 1 : 0);
+        else if (key.return || input === " ")
+            props.submit(choices[props.selected]?.value === "yes");
+    });
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "green", bold: true }, "Confirm Keating setup"), React.createElement(Text, null, `Provider: ${props.answers.defaultProvider}`), React.createElement(Text, null, `Model: ${props.answers.defaultModel}`), React.createElement(Text, null, `Thinking: ${props.answers.defaultThinking}`), React.createElement(Text, null, `Runtime: ${props.answers.runtimePreference}`), React.createElement(Text, null, ""), ...choices.map((choice, index) => React.createElement(Text, { key: choice.value, color: index === props.selected ? "green" : undefined }, `${index === props.selected ? ">" : " "} ${choice.label}`)));
+}
+function SetupApp(props) {
+    const app = useApp();
+    const [step, setStep] = useState("provider");
+    const [answers, setAnswers] = useState(props.initial);
+    const [providerIndex, setProviderIndex] = useState(selectedIndex(PROVIDERS, props.initial.defaultProvider));
+    const [modelIndex, setModelIndex] = useState(0);
+    const [thinkingIndex, setThinkingIndex] = useState(selectedIndex(THINKING, props.initial.defaultThinking));
+    const [runtimeIndex, setRuntimeIndex] = useState(selectedIndex(RUNTIMES, props.initial.runtimePreference));
+    const [summaryIndex, setSummaryIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === "c"))
+            app.exit();
+    });
+    if (step === "provider") {
+        return React.createElement(Menu, {
+            title: "Choose default provider",
+            choices: PROVIDERS,
+            selected: providerIndex,
+            setSelected: setProviderIndex,
+            submit: () => {
+                const provider = PROVIDERS[providerIndex]?.value ?? "google";
+                if (provider === "custom")
+                    setStep("customProvider");
+                else {
+                    const models = MODELS_BY_PROVIDER[provider] ?? MODELS_BY_PROVIDER.custom;
+                    setAnswers((current) => ({ ...current, defaultProvider: provider, defaultModel: models[0]?.value ?? current.defaultModel }));
+                    setModelIndex(0);
+                    setStep("model");
+                }
+            }
+        });
+    }
+    if (step === "customProvider") {
+        return React.createElement(TextPrompt, {
+            title: "Custom provider name",
+            initialValue: answers.defaultProvider === "custom" ? "google" : answers.defaultProvider,
+            submit: (value) => {
+                setAnswers((current) => ({ ...current, defaultProvider: value }));
+                setStep("customModel");
+            }
+        });
+    }
+    if (step === "model") {
+        const models = MODELS_BY_PROVIDER[answers.defaultProvider] ?? MODELS_BY_PROVIDER.custom;
+        return React.createElement(Menu, {
+            title: "Choose default model",
+            choices: models,
+            selected: modelIndex,
+            setSelected: setModelIndex,
+            submit: () => {
+                const model = models[modelIndex]?.value ?? "custom";
+                if (model === "custom")
+                    setStep("customModel");
+                else {
+                    setAnswers((current) => ({ ...current, defaultModel: model }));
+                    setStep("thinking");
+                }
+            }
+        });
+    }
+    if (step === "customModel") {
+        return React.createElement(TextPrompt, {
+            title: "Custom model name",
+            initialValue: answers.defaultModel,
+            submit: (value) => {
+                setAnswers((current) => ({ ...current, defaultModel: value }));
+                setStep("thinking");
+            }
+        });
+    }
+    if (step === "thinking") {
+        return React.createElement(Menu, {
+            title: "Choose thinking effort",
+            choices: THINKING,
+            selected: thinkingIndex,
+            setSelected: setThinkingIndex,
+            submit: () => {
+                setAnswers((current) => ({ ...current, defaultThinking: THINKING[thinkingIndex]?.value ?? "medium" }));
+                setStep("runtime");
+            }
+        });
+    }
+    if (step === "runtime") {
+        return React.createElement(Menu, {
+            title: "Choose runtime preference",
+            choices: RUNTIMES,
+            selected: runtimeIndex,
+            setSelected: setRuntimeIndex,
+            submit: () => {
+                setAnswers((current) => ({ ...current, runtimePreference: RUNTIMES[runtimeIndex]?.value ?? "prefer-standalone" }));
+                setStep("summary");
+            }
+        });
+    }
+    return React.createElement(Summary, {
+        answers,
+        selected: summaryIndex,
+        setSelected: setSummaryIndex,
+        submit: (confirmed) => {
+            if (confirmed) {
+                props.onComplete(answers);
+                app.exit();
+            }
+            else {
+                setStep("provider");
+            }
+        }
+    });
+}
+export async function runInteractiveSetup(initial) {
+    let completed = null;
+    const instance = render(React.createElement(SetupApp, {
+        initial,
+        onComplete: (answers) => {
+            completed = answers;
+        }
+    }));
+    await instance.waitUntilExit();
+    return completed;
+}

package/dist/src/cli/web.js

@@ -0,0 +1,84 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { access, readdir, stat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { color } from "../core/theme.js";
+const WEB_SOURCE_PATHS = [
+    "src",
+    "public",
+    "index.html",
+    "package.json",
+    "vite.config.ts",
+    "nitro.config.ts",
+];
+async function newestMtimeMs(path) {
+    try {
+        const entry = await stat(path);
+        if (!entry.isDirectory())
+            return entry.mtimeMs;
+        let newest = entry.mtimeMs;
+        const children = await readdir(path, { withFileTypes: true });
+        for (const child of children) {
+            newest = Math.max(newest, await newestMtimeMs(join(path, child.name)));
+        }
+        return newest;
+    }
+    catch {
+        return 0;
+    }
+}
+async function warnIfWebBuildIsStale(pkgRoot, nitroServerPath) {
+    const buildMtimeMs = (await stat(nitroServerPath)).mtimeMs;
+    const webRoot = join(pkgRoot, "web");
+    let newestSourceMtimeMs = 0;
+    for (const relativePath of WEB_SOURCE_PATHS) {
+        newestSourceMtimeMs = Math.max(newestSourceMtimeMs, await newestMtimeMs(join(webRoot, relativePath)));
+    }
+    if (newestSourceMtimeMs <= buildMtimeMs)
+        return;
+    console.warn(`${color.warn}Warning: web sources are newer than web/.output.${color.reset}`);
+    console.warn("`keating web` serves the last production build, not the live Vite source tree.");
+    console.warn("Use `mise run web` for hot reload, or rebuild with `bun run --cwd web build` before launching.");
+}
+/**
+ * Starts the Keating Web UI server using Nitro.
+ * Port-incrementing logic is now handled by Nitro's runtime
+ * or can be passed via the PORT environment variable.
+ */
+export async function serveWeb(port = 3000) {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    // Navigate from dist/src/cli/web.js to project root
+    const pkgRoot = join(currentDir, "..", "..", "..");
+    const nitroServerPath = join(pkgRoot, "web", ".output", "server", "index.mjs");
+    try {
+        await access(nitroServerPath);
+    }
+    catch (error) {
+        console.error(`${color.err}Error: Could not find Nitro server at ${nitroServerPath}${color.reset}`);
+        console.error("Please run the build command first:");
+        console.error("  bun run --cwd web build");
+        process.exit(1);
+    }
+    await warnIfWebBuildIsStale(pkgRoot, nitroServerPath);
+    process.stdout.write(`${color.ok}${color.bold} Keating Web Server ${color.reset}  ${color.parchment}port ${port}${color.reset}\n`);
+    const env = {
+        ...process.env,
+        PORT: port.toString(),
+        NITRO_PORT: port.toString()
+    };
+    // Run the Nitro server in a child process
+    const child = spawn(process.execPath, [nitroServerPath], {
+        env,
+        stdio: "inherit",
+    });
+    child.on("error", (err) => {
+        console.error(`${color.err}Failed to start Nitro server:${color.reset}`, err);
+    });
+    // Handle termination signals
+    const cleanup = () => {
+        child.kill();
+        process.exit();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+}