@launch11/srgical 0.0.1

package/dist/ui/studio.js

@@ -0,0 +1,704 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchStudio = launchStudio;
+exports.formatTrackerSummary = formatTrackerSummary;
+exports.buildStudioHeaderContent = buildStudioHeaderContent;
+exports.formatPlanningPackSummary = formatPlanningPackSummary;
+exports.renderWorkspaceSelectionMessage = renderWorkspaceSelectionMessage;
+exports.resolveStudioWorkspaceInput = resolveStudioWorkspaceInput;
+const node_path_1 = __importDefault(require("node:path"));
+const blessed_1 = __importDefault(require("blessed"));
+const agent_1 = require("../core/agent");
+const execution_controls_1 = require("../core/execution-controls");
+const execution_state_1 = require("../core/execution-state");
+const planning_pack_state_1 = require("../core/planning-pack-state");
+const studio_session_1 = require("../core/studio-session");
+const workspace_1 = require("../core/workspace");
+const READY_FOOTER = " Enter send message   PgUp/PgDn scroll   /workspace switch repo   /agents tools   /write save plan   /preview safe preview   /run execute next step   /quit exit ";
+const ACTIVITY_FRAMES = ["[    ]", "[=   ]", "[==  ]", "[=== ]", "[ ===]", "[  ==]", "[   =]"];
+async function launchStudio(options = {}) {
+    let workspace = (0, workspace_1.resolveWorkspace)(options.workspace);
+    let messages = await (0, studio_session_1.loadStudioSession)(workspace);
+    const screen = blessed_1.default.screen({
+        smartCSR: true,
+        fullUnicode: true,
+        title: "srgical studio"
+    });
+    const header = blessed_1.default.box({
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: 3,
+        tags: true,
+        style: {
+            fg: "#fff8ef",
+            bg: "#1b1a1f"
+        },
+        content: buildStudioHeaderContent(workspace, null)
+    });
+    const transcript = blessed_1.default.box({
+        top: 3,
+        left: 0,
+        width: "72%",
+        height: "100%-7",
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        keys: true,
+        vi: true,
+        padding: {
+            top: 1,
+            right: 2,
+            bottom: 1,
+            left: 2
+        },
+        border: {
+            type: "line"
+        },
+        label: " Transcript ",
+        style: {
+            fg: "#f7efe6",
+            bg: "#141318",
+            border: {
+                fg: "#ff7a59"
+            },
+            scrollbar: {
+                bg: "#ff7a59"
+            }
+        }
+    });
+    const sidebar = blessed_1.default.box({
+        top: 3,
+        left: "72%",
+        width: "28%",
+        height: "100%-7",
+        tags: true,
+        padding: {
+            top: 1,
+            right: 1,
+            bottom: 1,
+            left: 1
+        },
+        border: {
+            type: "line"
+        },
+        label: " Control Room ",
+        style: {
+            fg: "#d9fff8",
+            bg: "#11161c",
+            border: {
+                fg: "#4de2c5"
+            }
+        }
+    });
+    const input = blessed_1.default.textbox({
+        bottom: 1,
+        left: 0,
+        width: "100%",
+        height: 3,
+        inputOnFocus: true,
+        border: {
+            type: "line"
+        },
+        label: " Message / Command ",
+        style: {
+            fg: "#fff8ef",
+            bg: "#1a1112",
+            border: {
+                fg: "#ffb14a"
+            }
+        }
+    });
+    const footer = blessed_1.default.box({
+        bottom: 0,
+        left: 0,
+        width: "100%",
+        height: 1,
+        tags: true,
+        style: {
+            fg: "#bfb8c7",
+            bg: "#1b1a1f"
+        },
+        content: READY_FOOTER
+    });
+    screen.append(header);
+    screen.append(transcript);
+    screen.append(sidebar);
+    screen.append(input);
+    screen.append(footer);
+    let busy = false;
+    let busyMode = null;
+    let busyStartedAt = null;
+    let activityFrameIndex = 0;
+    let activityTimer;
+    let latestPackState = null;
+    let agentSummary = "checking...";
+    let planningPackSummary = "not checked";
+    let trackerSummary = "loading...";
+    let executionSummary = "never run";
+    function setSidebar(status) {
+        const planningPaths = (0, workspace_1.getPlanningPackPaths)(workspace);
+        sidebar.setContent([
+            "{bold}Workspace{/bold}",
+            `root: ${workspace}`,
+            `plan dir: ${planningPaths.dir}`,
+            "",
+            "{bold}Agent{/bold}",
+            agentSummary,
+            "",
+            "{bold}Planning Pack{/bold}",
+            planningPackSummary,
+            "",
+            "{bold}Tracker{/bold}",
+            trackerSummary,
+            "",
+            "{bold}Last Run{/bold}",
+            executionSummary,
+            "",
+            "{bold}Commands{/bold}",
+            "/workspace [path]  inspect or switch planning view",
+            "/agents  list supported tools and the current session choice",
+            "/agent <id>  switch the active agent for this workspace",
+            "/write  put the current plan on disk",
+            "/preview  inspect the next execution without invoking the active agent",
+            "/run    execute .srgical/04-next-agent-prompt.md",
+            "/help   show the workflow and key controls",
+            "/quit   close the studio",
+            "",
+            "{bold}State{/bold}",
+            status ?? getActivityState()
+        ].join("\n"));
+    }
+    function setFooter(status) {
+        footer.setContent(status ?? getFooterContent());
+    }
+    function getActivityState() {
+        if (!busy || !busyMode || busyStartedAt === null) {
+            return "ready";
+        }
+        return `${getActivityFrame()} ${describeBusyMode(busyMode)} (${formatElapsed(Date.now() - busyStartedAt)})`;
+    }
+    function getFooterContent() {
+        if (!busy || !busyMode || busyStartedAt === null) {
+            return READY_FOOTER;
+        }
+        return ` ${getActivityFrame()} ${describeBusyMode(busyMode)}   elapsed ${formatElapsed(Date.now() - busyStartedAt)}   planner and agent calls can take a moment `;
+    }
+    function getActivityFrame() {
+        return ACTIVITY_FRAMES[activityFrameIndex % ACTIVITY_FRAMES.length];
+    }
+    function startBusy(mode, status) {
+        busy = true;
+        busyMode = mode;
+        busyStartedAt = Date.now();
+        activityFrameIndex = 0;
+        stopActivityTimer();
+        setSidebar(status);
+        setFooter(status);
+        screen.render();
+        activityTimer = setInterval(() => {
+            activityFrameIndex += 1;
+            setSidebar(status);
+            setFooter(status);
+            screen.render();
+        }, 1000);
+    }
+    function stopBusy() {
+        busy = false;
+        busyMode = null;
+        busyStartedAt = null;
+        activityFrameIndex = 0;
+        stopActivityTimer();
+    }
+    function stopActivityTimer() {
+        if (activityTimer) {
+            clearInterval(activityTimer);
+            activityTimer = undefined;
+        }
+    }
+    function renderTranscript() {
+        const rendered = messages
+            .map((message) => {
+            const tone = message.role === "user"
+                ? "{#ffb14a-fg}YOU{/}"
+                : message.role === "assistant"
+                    ? "{#4de2c5-fg}PLANNER{/}"
+                    : "{#ff7a59-fg}SYSTEM{/}";
+            return `${tone}\n${message.content}`;
+        })
+            .join("\n\n");
+        transcript.setContent(rendered);
+        transcript.setScrollPerc(100);
+    }
+    function scrollTranscript(lines) {
+        transcript.scroll(lines);
+        screen.render();
+    }
+    async function appendMessage(message) {
+        messages.push(message);
+        await (0, studio_session_1.saveStudioSession)(workspace, messages);
+    }
+    async function refreshEnvironment() {
+        const [storedAgentId, packState] = await Promise.all([
+            (0, studio_session_1.loadStoredActiveAgentId)(workspace),
+            (0, planning_pack_state_1.readPlanningPackState)(workspace)
+        ]);
+        let agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
+        if (!storedAgentId) {
+            const availableAgents = agentState.statuses.filter((status) => status.available);
+            if (availableAgents.length === 1) {
+                agentState = await (0, agent_1.selectPrimaryAgent)(workspace, availableAgents[0].id);
+            }
+        }
+        latestPackState = packState;
+        header.setContent(buildStudioHeaderContent(workspace, packState));
+        agentSummary = formatAgentSummary(agentState.status, agentState.statuses);
+        planningPackSummary = formatPlanningPackSummary(workspace, packState);
+        trackerSummary = formatTrackerSummary(packState.currentPosition);
+        executionSummary = formatExecutionSummary(packState.lastExecution);
+        setSidebar();
+        setFooter();
+        renderTranscript();
+        screen.render();
+    }
+    async function handleSlashCommand(command) {
+        if (command === "/quit") {
+            screen.destroy();
+            return;
+        }
+        if (command === "/workspace") {
+            const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace));
+            await appendMessage({
+                role: "system",
+                content: renderWorkspaceSelectionMessage(workspace, packState)
+            });
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            screen.render();
+            return;
+        }
+        if (command.startsWith("/workspace")) {
+            const requestedWorkspace = command.slice("/workspace".length).trim();
+            if (!requestedWorkspace) {
+                const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace));
+                await appendMessage({
+                    role: "system",
+                    content: renderWorkspaceSelectionMessage(workspace, packState)
+                });
+                renderTranscript();
+                setSidebar();
+                setFooter();
+                screen.render();
+                return;
+            }
+            const nextWorkspace = resolveStudioWorkspaceInput(workspace, requestedWorkspace);
+            setSidebar("switching planning view...");
+            setFooter(" Switching planning view... ");
+            screen.render();
+            workspace = nextWorkspace;
+            messages = await (0, studio_session_1.loadStudioSession)(workspace);
+            await refreshEnvironment();
+            await appendMessage({
+                role: "system",
+                content: [
+                    `Now looking at ${workspace}.`,
+                    "",
+                    renderWorkspaceSelectionMessage(workspace, latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace)))
+                ].join("\n")
+            });
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            screen.render();
+            return;
+        }
+        if (command === "/agents") {
+            const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
+            await appendMessage({
+                role: "system",
+                content: renderAgentSelectionMessage(agentState.status, agentState.statuses)
+            });
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            screen.render();
+            return;
+        }
+        if (command.startsWith("/agent")) {
+            const requestedId = command.slice("/agent".length).trim().toLowerCase();
+            if (!requestedId) {
+                const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
+                await appendMessage({
+                    role: "system",
+                    content: [
+                        "Usage: `/agent codex` or `/agent claude`",
+                        "",
+                        renderAgentSelectionMessage(agentState.status, agentState.statuses)
+                    ].join("\n")
+                });
+                renderTranscript();
+                setSidebar();
+                setFooter();
+                screen.render();
+                return;
+            }
+            setSidebar("updating active agent...");
+            setFooter(" Updating active agent selection... ");
+            screen.render();
+            try {
+                const agentState = await (0, agent_1.selectPrimaryAgent)(workspace, requestedId);
+                await appendMessage({
+                    role: "system",
+                    content: [
+                        `Active agent set to ${agentState.status.label} for this workspace session.`,
+                        "",
+                        renderAgentSelectionMessage(agentState.status, agentState.statuses)
+                    ].join("\n")
+                });
+            }
+            catch (error) {
+                await appendMessage({
+                    role: "system",
+                    content: `Agent selection failed: ${error instanceof Error ? error.message : String(error)}`
+                });
+            }
+            finally {
+                await refreshEnvironment();
+            }
+            return;
+        }
+        if (command === "/help") {
+            await appendMessage({
+                role: "system",
+                content: [
+                    "Workflow:",
+                    "1. Talk normally to sharpen the plan against the real repo.",
+                    "2. Run `/workspace <path>` when you want to change which repo and planning directory you are looking at.",
+                    "3. Run `/agents` to inspect available tools and `/agent <id>` when you want to switch the workspace session.",
+                    "4. Run `/write` when the shape is ready to put the plan on disk inside `.srgical/`.",
+                    "5. Run `/preview` to inspect the next execution safely before writes happen.",
+                    "6. Run `/run` when you want the active agent to execute the next eligible tracker block.",
+                    "",
+                    "Controls:",
+                    "- `Enter` sends the current message.",
+                    "- `PageUp` and `PageDown` scroll the transcript.",
+                    "- `/quit` closes the studio."
+                ].join("\n")
+            });
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            screen.render();
+            return;
+        }
+        if (command === "/preview") {
+            const paths = (0, workspace_1.getPlanningPackPaths)(workspace);
+            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+            if (!packState.packPresent) {
+                await appendMessage({
+                    role: "system",
+                    content: "Execution preview unavailable: no .srgical planning pack was found yet."
+                });
+                renderTranscript();
+                setSidebar();
+                setFooter();
+                screen.render();
+                return;
+            }
+            const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
+            await appendMessage({
+                role: "system",
+                content: (0, execution_controls_1.renderDryRunPreview)(prompt, packState.nextStepSummary, packState.currentPosition.nextRecommended).join("\n")
+            });
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            screen.render();
+            return;
+        }
+        if (command === "/write") {
+            startBusy("pack");
+            try {
+                const result = await (0, agent_1.writePlanningPack)(workspace, messages);
+                await appendMessage({
+                    role: "system",
+                    content: `Planning pack updated. Summary:\n${result}`
+                });
+            }
+            catch (error) {
+                await appendMessage({
+                    role: "system",
+                    content: `Pack generation failed: ${error instanceof Error ? error.message : String(error)}`
+                });
+            }
+            finally {
+                stopBusy();
+                await refreshEnvironment();
+            }
+            return;
+        }
+        if (command === "/run") {
+            const paths = (0, workspace_1.getPlanningPackPaths)(workspace);
+            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+            if (!(0, execution_controls_1.hasQueuedNextStep)(packState.currentPosition.nextRecommended)) {
+                await appendMessage({
+                    role: "system",
+                    content: (0, execution_controls_1.formatNoQueuedNextStepMessage)("studio")
+                });
+                renderTranscript();
+                setSidebar();
+                setFooter();
+                screen.render();
+                return;
+            }
+            startBusy("run");
+            try {
+                const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
+                const result = await (0, agent_1.runNextPrompt)(workspace, prompt);
+                await (0, execution_state_1.saveExecutionState)(workspace, "success", "studio", result);
+                await appendMessage({
+                    role: "system",
+                    content: `Execution run finished. ${(0, agent_1.getPrimaryAgentAdapter)().label} summary:\n${result}`
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                await (0, execution_state_1.saveExecutionState)(workspace, "failure", "studio", message);
+                const refreshedPackState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+                await appendMessage({
+                    role: "system",
+                    content: (0, execution_controls_1.formatExecutionFailureMessage)(message, refreshedPackState.nextStepSummary, refreshedPackState.currentPosition.nextRecommended, "studio")
+                });
+            }
+            finally {
+                stopBusy();
+                await refreshEnvironment();
+            }
+            return;
+        }
+        await appendMessage({
+            role: "system",
+            content: `Unknown command: ${command}`
+        });
+        renderTranscript();
+        setSidebar();
+        setFooter();
+        screen.render();
+    }
+    input.on("submit", async (value) => {
+        const text = value.trim();
+        input.clearValue();
+        if (!text || busy) {
+            screen.render();
+            return;
+        }
+        if (text.startsWith("/")) {
+            await handleSlashCommand(text);
+            input.focus();
+            return;
+        }
+        startBusy("planner");
+        await appendMessage({
+            role: "user",
+            content: text
+        });
+        renderTranscript();
+        setSidebar();
+        setFooter();
+        screen.render();
+        try {
+            const reply = await (0, agent_1.requestPlannerReply)(workspace, messages);
+            await appendMessage({
+                role: "assistant",
+                content: reply
+            });
+        }
+        catch (error) {
+            await appendMessage({
+                role: "system",
+                content: `Planner call failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+        }
+        finally {
+            stopBusy();
+            renderTranscript();
+            setSidebar();
+            setFooter();
+            input.focus();
+            screen.render();
+        }
+    });
+    screen.key(["C-c"], () => {
+        stopBusy();
+        screen.destroy();
+    });
+    for (const element of [screen, transcript, input]) {
+        element.key(["pageup", "ppage"], () => {
+            scrollTranscript(-5);
+        });
+        element.key(["pagedown", "npage"], () => {
+            scrollTranscript(5);
+        });
+    }
+    renderTranscript();
+    setSidebar("booting...");
+    setFooter(" Starting studio... ");
+    screen.render();
+    input.focus();
+    await refreshEnvironment();
+    await ensureFirstRunOrientation();
+    async function ensureFirstRunOrientation() {
+        if (!latestPackState || !isDefaultStudioSession(messages)) {
+            return;
+        }
+        await appendMessage({
+            role: "system",
+            content: renderWorkspaceSelectionMessage(workspace, latestPackState)
+        });
+        renderTranscript();
+        setSidebar();
+        setFooter();
+        screen.render();
+    }
+}
+function describeBusyMode(mode) {
+    switch (mode) {
+        case "planner":
+            return `waiting on ${(0, agent_1.getPrimaryAgentAdapter)().label} planner`;
+        case "pack":
+            return `writing planning pack via ${(0, agent_1.getPrimaryAgentAdapter)().label}`;
+        case "run":
+            return `executing next-agent prompt via ${(0, agent_1.getPrimaryAgentAdapter)().label}`;
+    }
+}
+function formatElapsed(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes === 0) {
+        return `${seconds}s`;
+    }
+    return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+}
+function formatTrackerSummary(currentPosition) {
+    if (!currentPosition.lastCompleted && !currentPosition.nextRecommended) {
+        return "current position unavailable";
+    }
+    const lines = [
+        `last: ${currentPosition.lastCompleted ?? "unknown"}`,
+        `next: ${currentPosition.nextRecommended ?? "none queued"}`
+    ];
+    if (currentPosition.updatedAt) {
+        lines.push(`updated: ${currentPosition.updatedAt}`);
+    }
+    return lines.join("\n");
+}
+function formatExecutionSummary(execution) {
+    if (!execution) {
+        return "no execution recorded yet";
+    }
+    const label = execution.status === "success" ? "success" : "failure";
+    return `${label} via ${execution.source}\n${execution.updatedAt}\n${execution.summary}`;
+}
+function formatAgentSummary(activeAgent, statuses) {
+    return [`active: ${activeAgent.label}`, ...statuses.map((status) => formatAgentStatusLine(status, status.id === activeAgent.id))]
+        .join("\n");
+}
+function buildStudioHeaderContent(workspace, packState) {
+    const workspaceName = node_path_1.default.basename(workspace) || workspace;
+    const packLabel = packState ? formatPlanningPackPill(packState) : "{#ffb14a-fg}PACK STATUS LOADING{/}";
+    return ` {bold}SRGICAL STUDIO{/bold}   ${workspaceName}   ${packLabel}`;
+}
+function formatPlanningPackSummary(workspace, packState) {
+    const lines = [
+        `state: ${describePlanningPackState(packState)}`,
+        `dir: ${(0, workspace_1.getPlanningPackPaths)(workspace).dir}`
+    ];
+    if (!packState.packPresent) {
+        lines.push("next: /write will put the plan on disk");
+    }
+    else if (packState.trackerReadable) {
+        lines.push(packState.currentPosition.nextRecommended ? "next: /preview or /run when ready" : "next: plan is written; queue more work when ready");
+    }
+    else {
+        lines.push("next: rewrite or repair the pack before running");
+    }
+    return lines.join("\n");
+}
+function renderWorkspaceSelectionMessage(workspace, packState) {
+    return [
+        "Planning view:",
+        `- workspace: ${workspace}`,
+        `- planning dir: ${(0, workspace_1.getPlanningPackPaths)(workspace).dir}`,
+        `- plan status: ${describePlanningPackState(packState)}`,
+        "",
+        "Use `/workspace <path>` to switch repos.",
+        !packState.packPresent
+            ? "Use `/write` when you want to put the current plan on disk."
+            : "Use `/write` when you want to refresh the plan on disk from this transcript."
+    ].join("\n");
+}
+function renderAgentSelectionMessage(activeAgent, statuses) {
+    return [
+        `Current active agent: ${activeAgent.label}${activeAgent.available ? "" : " (selected but currently unavailable)"}`,
+        "",
+        "Detected support:",
+        ...statuses.map((status) => formatAgentStatusLine(status, status.id === activeAgent.id))
+    ].join("\n");
+}
+function formatAgentStatusLine(status, selected) {
+    const prefix = selected ? "*" : "-";
+    const detail = status.available ? `ready (${status.version ?? "version unknown"})` : formatUnavailableAgentDetail(status);
+    return `${prefix} ${status.id}: ${detail}`;
+}
+function formatUnavailableAgentDetail(status) {
+    const reason = status.error ?? "unknown issue";
+    return reason.toLowerCase().includes("install ") ? `on deck (${reason})` : `attention needed (${reason})`;
+}
+function resolveStudioWorkspaceInput(currentWorkspace, requestedWorkspace) {
+    const trimmed = requestedWorkspace.trim();
+    if (!trimmed) {
+        return currentWorkspace;
+    }
+    const pathModule = shouldUseWindowsPathSemantics(currentWorkspace, trimmed) ? node_path_1.default.win32 : node_path_1.default;
+    return pathModule.isAbsolute(trimmed) ? pathModule.resolve(trimmed) : pathModule.resolve(currentWorkspace, trimmed);
+}
+function shouldUseWindowsPathSemantics(currentWorkspace, requestedWorkspace) {
+    return (isWindowsAbsolutePath(currentWorkspace) ||
+        isWindowsAbsolutePath(requestedWorkspace) ||
+        isWindowsUncPath(currentWorkspace) ||
+        isWindowsUncPath(requestedWorkspace));
+}
+function isWindowsAbsolutePath(value) {
+    return /^[A-Za-z]:[\\/]/.test(value);
+}
+function isWindowsUncPath(value) {
+    return /^\\\\[^\\]+\\[^\\]+/.test(value);
+}
+function isDefaultStudioSession(messages) {
+    return (messages.length === studio_session_1.DEFAULT_STUDIO_MESSAGES.length &&
+        messages.every((message, index) => message.role === studio_session_1.DEFAULT_STUDIO_MESSAGES[index]?.role &&
+            message.content === studio_session_1.DEFAULT_STUDIO_MESSAGES[index]?.content));
+}
+function describePlanningPackState(packState) {
+    if (!packState.packPresent) {
+        return "not written yet";
+    }
+    if (!packState.trackerReadable) {
+        return "written but needs attention";
+    }
+    return "written to disk";
+}
+function formatPlanningPackPill(packState) {
+    if (!packState.packPresent) {
+        return "{#ffb14a-fg}PLAN NOT WRITTEN{/}";
+    }
+    if (!packState.trackerReadable) {
+        return "{#ff7a59-fg}PACK NEEDS ATTENTION{/}";
+    }
+    return "{#4de2c5-fg}PLAN WRITTEN{/}";
+}