@mozole/cli 1.4.3 → 2.0.0

package/dist/commands/ui.js

@@ -1,481 +1,154 @@
 import path from "node:path";
-import { stdin, stdout } from "node:process";
-import { createInterface } from "node:readline/promises";
-import { sanitizeTerminalText } from "../output-safety.js";
-import { renderProgressBar } from "../progress.js";
-import { TemplateServerManager, } from "../template/servers.js";
-import { findTemplateRoot } from "../template/workspace.js";
-import { CLI_VERSION } from "../version.js";
-import { adoptCommand } from "./adopt.js";
-import { cceInstallCommand } from "./cce.js";
+import { render } from "ink";
+import pc from "picocolors";
+import prompts from "prompts";
+import React from "react";
+import { serverManager } from "../server/manager.js";
+import { CockpitApp } from "../ui/CockpitApp.js";
+import { discoverWorkspaceProjects, findProjectRoot, findPrototypeRoot, } from "../utils/fs.js";
 import { doctorCommand } from "./doctor.js";
-import { newCommand } from "./new.js";
-import { qaCommand } from "./qa.js";
-import { statsCommand } from "./stats.js";
-import { templateAdoptCommand } from "./template.js";
+import { phaseCommand } from "./phase.js";
+import { repomapCommand } from "./repomap.js";
 import { verifyCommand } from "./verify.js";
-const actions = [
-    {
-        label: "Doctor",
-        detail: "Inspect project, toolchain & AI runtime health",
-        key: "1",
-        kind: "command",
-        run: (cwd, output, opts) => doctorCommand(cwd, output, opts),
-    },
-    {
-        label: "Verify",
-        detail: "Run strict lint, typecheck, tests & build",
-        key: "2",
-        kind: "command",
-        run: (cwd, output, opts) => verifyCommand(cwd, output, opts),
-    },
-    {
-        label: "QA",
-        detail: "Run deterministic, screenshot-free browser probes",
-        key: "3",
-        kind: "command",
-        run: (cwd, output, opts) => qaCommand(cwd, {
-            interactive: false,
-            visual: false,
-            onProgress: opts?.onProgress,
-        }, output),
-    },
-    {
-        label: "Stats",
-        detail: "Inspect token savings & verification cache telemetry",
-        key: "4",
-        kind: "command",
-        run: (cwd, output, opts) => statsCommand(cwd, output, opts),
-    },
-    {
-        label: "Install CCE",
-        detail: "Provision persistent uv & code-context-engine runtime",
-        key: "5",
-        kind: "install",
-    },
-    {
-        label: "New project",
-        detail: "Scaffold a static-first production-ready application",
-        key: "6",
-        kind: "create",
-    },
-    {
-        label: "Adopt project",
-        detail: "Integrate Mozole toolchain into an existing app",
-        key: "7",
-        kind: "adopt",
-    },
-    {
-        label: "Servers",
-        detail: "Start & stop template project npm servers",
-        key: "8",
-        kind: "servers",
-    },
-    {
-        label: "Exit",
-        detail: "Return to your shell",
-        key: "9",
-        kind: "exit",
-    },
-];
-const ansi = {
-    alternateEnter: "\u001B[?1049h",
-    alternateExit: "\u001B[?1049l",
-    clear: "\u001B[2J\u001B[H",
-    cursorHide: "\u001B[?25l",
-    cursorShow: "\u001B[?25h",
-    reset: "\u001B[0m",
-};
-const ansiSequence = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
-function paint(value, code, color) {
-    return color ? `\u001B[${code}m${value}${ansi.reset}` : value;
-}
-function clamp(value, width) {
-    if (width < 2)
-        return "";
-    const plain = value.replace(ansiSequence, "");
-    return plain.length <= width
-        ? `${value}${" ".repeat(width - plain.length)}`
-        : `${plain.slice(0, Math.max(0, width - 1))}…`;
-}
-function box(lines, width, color, sectionTitle) {
-    const inner = Math.max(10, width - 2);
-    let topBorder = "─".repeat(inner);
-    if (sectionTitle) {
-        const titleText = ` ${sectionTitle} `;
-        if (titleText.length < inner - 4) {
-            topBorder = `──${titleText}${"─".repeat(inner - 2 - titleText.length)}`;
-        }
-    }
-    const top = `${paint("╭", 90, color)}${paint(topBorder, 90, color)}${paint("╮", 90, color)}`;
-    const bottom = `${paint("╰", 90, color)}${paint("─".repeat(inner), 90, color)}${paint("╯", 90, color)}`;
-    return [
-        top,
-        ...lines.map((line) => `${paint("│", 90, color)} ${clamp(line, inner - 2)} ${paint("│", 90, color)}`),
-        bottom,
-    ];
-}
-export function uiMenuText() {
-    return actions.map((action) => `${action.key}  ${action.label}`).join("\n");
-}
-export function uiDashboardFrame(state, dimensions, color = true) {
-    const width = Math.max(54, Math.min(100, dimensions.columns - 2));
-    const height = Math.max(20, dimensions.rows);
-    const title = paint("Mozole-cli", 96, color);
-    const version = paint(`v${CLI_VERSION}`, 90, color);
-    const subtitle = paint("COMMAND DECK", 95, color);
-    const copyright = paint("© MozoleStudio", 90, color);
-    const projectLabel = paint("PROJECT", 36, color);
-    const projectName = paint(sanitizeTerminalText(path.basename(state.cwd) || state.cwd), 97, color);
-    const header = [
-        `  ${paint("◆", 96, color)} ${title}  ${version}  ${paint("│", 90, color)}  ${subtitle}  ${paint("│", 90, color)}  ${copyright}`,
-        `  ${projectLabel}  ${projectName}`,
-    ];
-    const actionLines = actions.map((action, index) => {
-        const active = state.selected === index;
-        const marker = active ? paint("❯", 96, color) : paint("·", 90, color);
-        const key = paint(`[${action.key}]`, active ? 97 : 36, color);
-        const label = paint(action.label.padEnd(14), active ? 97 : 37, color);
-        const detail = paint(action.detail, active ? 96 : 90, color);
-        return `${marker} ${key} ${label} ${detail}`;
-    });
-    let statusBadge = paint("● READY  Select an operation", 92, color);
-    let progressLine;
-    if (state.busy) {
-        statusBadge = paint(`⟳ RUNNING  ${state.busy}`, 93, color);
-        if (state.progress) {
-            const bar = renderProgressBar(state.progress.current / state.progress.total, 14);
-            const stepInfo = paint(`[${state.progress.current}/${state.progress.total}]`, 97, color);
-            const msg = paint(sanitizeTerminalText(state.progress.message), 90, color);
-            progressLine = `  ${paint(bar, 36, color)} ${stepInfo} ${msg}`;
-        }
+export async function uiCommand(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const protoRoot = await findPrototypeRoot(cwd);
+    let projectRoot = await findProjectRoot(cwd);
+    if (projectRoot === protoRoot)
+        projectRoot = null;
+    const discoveredProjects = protoRoot
+        ? await discoverWorkspaceProjects(protoRoot)
+        : [];
+    let activeProject = options.project ?? null;
+    if (!activeProject && projectRoot) {
+        const matched = discoveredProjects.find((p) => p.path === projectRoot);
+        activeProject = matched ? matched.name : path.basename(projectRoot);
     }
-    else if (state.lastResult) {
-        if (state.lastResult.includes("COMPLETE")) {
-            statusBadge = paint(`✓ ${state.lastResult}`, 92, color);
+    let initialTab = "overview";
+    // If in prototype / monorepo workspace and no project specified
+    if (!projectRoot && protoRoot && discoveredProjects.length > 0) {
+        if (options.project) {
+            const matched = discoveredProjects.find((p) => p.name === options.project ||
+                p.relative === options.project ||
+                path.basename(p.path) === options.project);
+            if (matched) {
+                activeProject = matched.name;
+                projectRoot = matched.path;
+            }
+            else {
+                activeProject = options.project;
+                projectRoot = path.join(protoRoot, options.project);
+            }
         }
-        else if (state.lastResult.includes("FAILED")) {
-            statusBadge = paint(`✗ ${state.lastResult}`, 91, color);
+        else if (process.env.VITEST || options.interactive === false) {
+            // In automated tests or headless programmatic mode, prompt for selection if available
+            const choice = await prompts({
+                type: "select",
+                name: "project",
+                message: "Select an active client project:",
+                choices: discoveredProjects.map((p) => ({ title: p.name, value: p.name })),
+            });
+            if (choice?.project) {
+                const found = discoveredProjects.find((p) => p.name === choice.project);
+                activeProject = choice.project;
+                projectRoot = found ? found.path : path.join(protoRoot, choice.project);
+            }
+            else {
+                activeProject = discoveredProjects[0].name;
+                projectRoot = discoveredProjects[0].path;
+            }
         }
         else {
-            statusBadge = paint(state.lastResult, 97, color);
+            // In interactive terminal at monorepo root: default to first project and open projects explorer tab!
+            activeProject = discoveredProjects[0].name;
+            projectRoot = discoveredProjects[0].path;
+            initialTab = "projects";
         }
     }
-    const activity = state.log.length
-        ? state.log.slice(-4).map((l) => paint(`  ${l}`, 90, color))
-        : [paint("  No operation has run in this session.", 90, color)];
-    const frame = [
-        "",
-        ...header,
-        "",
-        ...box(actionLines, width, color, "OPERATIONS"),
-        "",
-        ...box([
-            `  ${statusBadge}`,
-            ...(progressLine ? ["", progressLine] : []),
-            "",
-            ...activity,
-        ], width, color, "STATUS & ACTIVITY"),
-        "",
-        paint("  ↑↓ / j k  navigate   enter  run   1–9  jump   r  redraw   q  exit", 90, color),
-        paint("  Normal QA is deterministic and screenshot-free. Visual QA remains explicit. · © MozoleStudio", 90, color),
-    ];
-    const padding = Math.max(0, height - frame.length - 1);
-    return `${ansi.clear}${frame.join("\n")}${"\n".repeat(padding)}`;
-}
-export function uiServerManagerFrame(root, servers, selected, dimensions, color = true, message = "") {
-    const width = Math.max(54, Math.min(100, dimensions.columns - 2));
-    const height = Math.max(20, dimensions.rows);
-    const rows = servers.length
-        ? servers.map((server, index) => {
-            const marker = selected === index ? paint("❯", 96, color) : paint("·", 90, color);
-            const statusCode = server.status === "running"
-                ? 92
-                : server.status === "failed"
-                    ? 91
-                    : server.status === "starting"
-                        ? 93
-                        : 90;
-            const status = paint(server.status.toUpperCase().padEnd(8), statusCode, color);
-            const address = server.status === "running"
-                ? `http://127.0.0.1:${server.port}`
-                : `preferred :${server.preferredPort}`;
-            return `${marker} ${status} ${sanitizeTerminalText(server.relativePath).padEnd(22)} ${address}`;
-        })
-        : [paint("  No projects found. Run `mozole new <name>` here.", 90, color)];
-    const frame = [
-        "",
-        `  ${paint("◆", 96, color)} ${paint("NPM SERVER MANAGER", 96, color)}`,
-        `  ${paint("TEMPLATE", 36, color)}  ${paint(sanitizeTerminalText(path.basename(root)), 97, color)}`,
-        "",
-        ...box(rows, width, color, "PROJECTS"),
-        "",
-        ...box([
-            `  ${sanitizeTerminalText(message || "Select a project and press Enter to start or stop it.")}`,
-        ], width, color, "STATUS"),
-        "",
-        paint("  ↑↓ / j k  navigate   enter / s  start-stop   a  start all   x  stop all   q / esc  back", 90, color),
-        paint("  Servers live for this UI session. Logs: .mozole/logs/servers/", 90, color),
-    ];
-    return `${ansi.clear}${frame.join("\n")}${"\n".repeat(Math.max(0, height - frame.length - 1))}`;
-}
-function hasColor(output) {
-    return (Boolean(output.isTTY) &&
-        !process.env.NO_COLOR &&
-        process.env.TERM !== "dumb");
-}
-function prompt(input, output, question) {
-    const readline = createInterface({ input, output });
-    return readline
-        .question(question)
-        .then((answer) => answer.trim())
-        .catch(() => undefined)
-        .finally(() => readline.close());
-}
-function waitForKey(input) {
-    return new Promise((resolve) => {
-        input.once("data", (chunk) => resolve(String(chunk)));
-    });
-}
-function statusLine(message) {
-    return sanitizeTerminalText(String(message))
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .slice(-5);
-}
-export async function uiCommand(cwd, output = console, streams = {}) {
-    const input = streams.input ?? stdin;
-    const terminalOutput = streams.output ?? stdout;
-    const interactive = streams.interactive ?? Boolean(input.isTTY && terminalOutput.isTTY);
-    if (!interactive || !input.setRawMode) {
-        output.error("UI requires an interactive terminal with ANSI support. Use `mozole doctor`, `mozole verify`, `mozole qa`, or `mozole stats` in CI.");
-        return 2;
+    const targetPath = projectRoot ?? cwd;
+    const projectName = activeProject ?? path.basename(targetPath);
+    // If programmatic action was requested (or prompted during non-interactive test)
+    let requestedAction = options.action;
+    if (!requestedAction && (process.env.VITEST || options.interactive === false)) {
+        const promptRes = await prompts({
+            type: "select",
+            name: "action",
+            message: "Select operation:",
+            choices: [
+                { title: "[01] Phase Status", value: "phase-status" },
+                { title: "[02] Phase Next", value: "phase-next" },
+                { title: "[03] Verify", value: "verify" },
+                { title: "[04] Server Start", value: "server-start" },
+                { title: "[05] Server Stop", value: "server-stop" },
+                { title: "[06] Repomap", value: "repomap" },
+                { title: "[07] Doctor", value: "doctor" },
+            ],
+        });
+        requestedAction = promptRes?.action;
     }
-    const state = { cwd, selected: 0, log: [] };
-    const directOutput = {
-        log: (message, ...optional) => output.log(sanitizeTerminalText(String(message ?? "")), ...optional.map((value) => sanitizeTerminalText(String(value ?? "")))),
-        error: (message, ...optional) => output.error(sanitizeTerminalText(String(message ?? "")), ...optional.map((value) => sanitizeTerminalText(String(value ?? "")))),
-    };
-    const color = hasColor(terminalOutput);
-    let entered = false;
-    let serverManager;
-    let serverViewRender;
-    let requestedExitCode;
-    const render = () => terminalOutput.write(uiDashboardFrame(state, {
-        columns: terminalOutput.columns ?? 100,
-        rows: terminalOutput.rows ?? 32,
-    }, color));
-    const enter = () => {
-        if (entered)
-            return;
-        terminalOutput.write(`${ansi.alternateEnter}${ansi.cursorHide}`);
-        input.setRawMode?.(true);
-        input.resume?.();
-        entered = true;
-        render();
-    };
-    const leave = () => {
-        if (!entered)
-            return;
-        input.setRawMode?.(false);
-        input.pause?.();
-        terminalOutput.write(`${ansi.cursorShow}${ansi.alternateExit}`);
-        entered = false;
-    };
-    const resize = () => (serverViewRender ?? render)();
-    terminalOutput.on("resize", resize);
-    const abort = () => leave();
-    process.once("SIGINT", abort);
-    process.once("SIGTERM", abort);
-    const dashboardOutput = {
-        log: (message) => {
-            state.log = statusLine(message);
-        },
-        error: (message) => {
-            state.log = statusLine(message);
-        },
-    };
-    async function runExternal(action) {
-        leave();
+    if (requestedAction) {
         try {
-            if (action.kind === "install") {
-                const code = await cceInstallCommand(cwd, directOutput);
-                state.lastResult = `${action.label} ${code === 0 ? "COMPLETE" : "FAILED"}`;
+            switch (requestedAction) {
+                case "phase-status":
+                    await phaseCommand({ action: "status", cwd: targetPath });
+                    break;
+                case "phase-next":
+                    await phaseCommand({ action: "next", cwd: targetPath });
+                    break;
+                case "verify":
+                    await verifyCommand({ cwd: targetPath });
+                    break;
+                case "server-start":
+                    await serverManager.startServer(projectName, targetPath);
+                    break;
+                case "server-stop":
+                    serverManager.stopServer(projectName);
+                    break;
+                case "repomap":
+                    await repomapCommand({ action: "sync", cwd: targetPath });
+                    break;
+                case "doctor":
+                    await doctorCommand();
+                    break;
             }
-            else {
-                const question = action.kind === "create"
-                    ? "New project name: "
-                    : "Project path to adopt: ";
-                const value = await prompt(input, terminalOutput, question);
-                if (!value) {
-                    state.lastResult = `${action.label} CANCELLED`;
-                    return;
-                }
-                const code = action.kind === "create"
-                    ? await newCommand(value, cwd, directOutput)
-                    : (await findTemplateRoot(cwd))
-                        ? await templateAdoptCommand(value, cwd, directOutput)
-                        : await adoptCommand(value, cwd, directOutput);
-                state.lastResult = `${action.label} ${code === 0 ? "COMPLETE" : "FAILED"}`;
-            }
-            await prompt(input, terminalOutput, "\nPress Enter to return to Mozole…");
-        }
-        finally {
-            enter();
         }
-    }
-    async function runServerManager() {
-        const root = await findTemplateRoot(cwd);
-        if (!root) {
-            state.lastResult = "Servers FAILED: no template workspace";
-            state.log = ["Run `mozole template init <folder>` first."];
-            render();
-            return;
-        }
-        serverManager ??= new TemplateServerManager(root);
-        let servers = await serverManager.refresh();
-        let selected = 0;
-        let message = "";
-        const draw = () => terminalOutput.write(uiServerManagerFrame(root, servers, selected, {
-            columns: terminalOutput.columns ?? 100,
-            rows: terminalOutput.rows ?? 32,
-        }, color, message));
-        serverViewRender = draw;
-        draw();
-        while (true) {
-            const key = await waitForKey(input);
-            if (key === "\u0003") {
-                requestedExitCode = 130;
-                serverViewRender = undefined;
-                return;
-            }
-            if (key === "q" || key === "Q" || key === "\u001B") {
-                state.lastResult = `${servers.filter((item) => item.status === "running").length} SERVER(S) RUNNING`;
-                serverViewRender = undefined;
-                render();
-                return;
+        catch (err) {
+            console.log(pc.red("\n┌─ OPERATION ERROR ──────────────────────────────────────────┐"));
+            const errMsg = err instanceof Error ? err.message : String(err);
+            for (const line of errMsg.split("\n")) {
+                console.log(pc.red(`│ [!] ${line}`));
             }
-            if (key === "\u001B[A" || key === "k") {
-                if (servers.length)
-                    selected = (selected + servers.length - 1) % servers.length;
-                draw();
-                continue;
-            }
-            if (key === "\u001B[B" || key === "j") {
-                if (servers.length)
-                    selected = (selected + 1) % servers.length;
-                draw();
-                continue;
-            }
-            if (key === "x" || key === "X") {
-                message = "Stopping all project servers…";
-                draw();
-                await serverManager.stopAll();
-                servers = serverManager.list();
-                message = "All project servers stopped.";
-                draw();
-                continue;
-            }
-            if (key === "a" || key === "A") {
-                for (const server of servers) {
-                    if (server.status === "running")
-                        continue;
-                    message = `Starting ${server.relativePath}…`;
-                    draw();
-                    await serverManager.start(server.relativePath);
-                    servers = serverManager.list();
-                }
-                message = "All available project servers started.";
-                draw();
-                continue;
-            }
-            if (key !== "s" && key !== "S" && key !== "\r" && key !== "\n")
-                continue;
-            const server = servers[selected];
-            if (!server)
-                continue;
-            if (server.status === "running" || server.status === "starting") {
-                message = `Stopping ${server.relativePath}…`;
-                draw();
-                await serverManager.stop(server.relativePath);
-            }
-            else {
-                message = `Starting ${server.relativePath}…`;
-                draw();
-                await serverManager.start(server.relativePath);
-            }
-            servers = serverManager.list();
-            const current = servers.find((candidate) => candidate.relativePath === server.relativePath);
-            message = current?.error
-                ? `${server.relativePath}: ${current.error}`
-                : `${server.relativePath}: ${current?.status ?? "stopped"}`;
-            draw();
+            console.log(pc.red("└────────────────────────────────────────────────────────────┘"));
         }
+        return;
     }
-    try {
-        enter();
-        while (true) {
-            const key = await waitForKey(input);
-            if (key === "\u0003")
-                return 130;
-            if (key === "q" || key === "Q" || key === "\u001B")
-                return 0;
-            if (key === "\u001B[A" || key === "k") {
-                state.selected = (state.selected + actions.length - 1) % actions.length;
-                render();
-                continue;
-            }
-            if (key === "\u001B[B" || key === "j") {
-                state.selected = (state.selected + 1) % actions.length;
-                render();
-                continue;
-            }
-            if (key === "r") {
-                render();
-                continue;
-            }
-            const direct = actions.findIndex((action) => action.key === key);
-            if (direct >= 0)
-                state.selected = direct;
-            if (key !== "\r" && key !== "\n" && direct < 0)
-                continue;
-            const action = actions[state.selected];
-            if (!action)
-                continue;
-            if (action.kind === "exit")
-                return 0;
-            if (action.kind === "servers") {
-                await runServerManager();
-                if (requestedExitCode !== undefined)
-                    return requestedExitCode;
-                continue;
-            }
-            if (action.kind !== "command") {
-                await runExternal(action);
-                continue;
-            }
-            state.busy = action.label;
-            delete state.progress;
-            render();
-            const code = await action.run?.(cwd, dashboardOutput, {
-                onProgress: (prog) => {
-                    state.progress = prog;
-                    render();
-                },
-            });
-            delete state.busy;
-            delete state.progress;
-            state.lastResult = `${action.label} ${code === 0 ? "COMPLETE" : "FAILED"}`;
-            render();
+    // Fullscreen Ink TUI Mode (Alternate Screen Buffer)
+    const isTTY = Boolean(process.stdout.isTTY);
+    if (isTTY) {
+        process.stdout.write("\x1b[?1049h\x1b[H");
+    }
+    const restore = () => {
+        if (isTTY) {
+            process.stdout.write("\x1b[?1049l\x1b[?25h");
         }
+    };
+    process.once("SIGINT", restore);
+    process.once("SIGTERM", restore);
+    try {
+        const instance = render(React.createElement(CockpitApp, {
+            projectRoot: targetPath,
+            activeProject: projectName,
+            protoRoot,
+            projects: discoveredProjects,
+            initialTab,
+            onExit: restore,
+        }));
+        await instance.waitUntilExit();
     }
     finally {
-        await serverManager?.stopAll();
-        leave();
-        terminalOutput.off("resize", resize);
-        process.removeListener("SIGINT", abort);
-        process.removeListener("SIGTERM", abort);
+        restore();
+        process.removeListener("SIGINT", restore);
+        process.removeListener("SIGTERM", restore);
     }
 }
 //# sourceMappingURL=ui.js.map