@supatest/cli 0.0.2 → 0.0.3

package/dist/modes/interactive.js

@@ -0,0 +1,430 @@
+/**
+ * Interactive mode entry point
+ * Launches the Ink UI and runs the agent with real-time updates
+ */
+import { render } from "ink";
+import React, { useEffect, useRef } from "react";
+import { config as envConfig } from "../config";
+import { CoreAgent } from "../core/agent";
+import { ReactPresenter } from "../presenters/react";
+import { ApiClient, ApiError } from "../services/api-client";
+import { App } from "../ui/App";
+import { KeypressProvider } from "../ui/contexts/KeypressContext";
+import { MouseProvider } from "../ui/contexts/MouseContext";
+import { SessionProvider, useSession } from "../ui/contexts/SessionContext";
+import { useBracketedPaste } from "../ui/hooks/useBracketedPaste";
+import { disableMouseEvents, enableMouseEvents } from "../ui/utils/mouse";
+import { logger } from "../utils/logger";
+import { createInkStdio, patchStdio } from "../utils/stdio";
+const CLI_VERSION = "0.0.1";
+/**
+ * Get human-readable description for tool call (used when resuming sessions)
+ */
+function getToolDescription(toolName, input) {
+    switch (toolName) {
+        case "Read":
+            return input?.file_path || "file";
+        case "Write":
+            return input?.file_path || "file";
+        case "Edit":
+            return input?.file_path || "file";
+        case "Bash": {
+            const cmd = input?.command || "";
+            return cmd.length > 60 ? `${cmd.substring(0, 60)}...` : cmd;
+        }
+        case "Glob":
+            return `pattern: "${input?.pattern || "files"}"`;
+        case "Grep": {
+            const pattern = input?.pattern || "code";
+            const path = input?.path;
+            return path ? `"${pattern}" (in ${path})` : `"${pattern}"`;
+        }
+        case "Task":
+            return input?.subagent_type || "task";
+        case "TodoWrite":
+            return "Updated todos";
+        case "BashOutput":
+        case "Command Output":
+            return input?.bash_id || "shell output";
+        default:
+            return toolName;
+    }
+}
+/**
+ * Agent Runner Component
+ * Runs the agent via CoreAgent and updates the UI context in real-time
+ */
+const AgentRunner = ({ config, sessionId, apiClient, onComplete }) => {
+    const { addMessage, updateLastMessage, updateMessageByToolId, setIsAgentRunning, updateStats, setTodos, shouldInterruptAgent, setShouldInterruptAgent, agentMode, planFilePath, } = useSession();
+    // Keep a ref to the agent so we can call abort()
+    const agentRef = useRef(null);
+    // When shouldInterruptAgent changes to true, abort the agent
+    useEffect(() => {
+        if (shouldInterruptAgent && agentRef.current) {
+            agentRef.current.abort();
+            setShouldInterruptAgent(false);
+        }
+    }, [shouldInterruptAgent, setShouldInterruptAgent]);
+    useEffect(() => {
+        let isMounted = true;
+        const runAgent = async () => {
+            setIsAgentRunning(true);
+            try {
+                // Set up environment for Claude Code
+                const baseUrl = `${config.supatestApiUrl}/v1/sessions/${sessionId}/anthropic`;
+                process.env.ANTHROPIC_BASE_URL = baseUrl;
+                process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
+                // Create presenter with callbacks to React state
+                const presenter = new ReactPresenter({
+                    addMessage: (msg) => {
+                        if (isMounted)
+                            addMessage(msg);
+                    },
+                    updateLastMessage: (update) => {
+                        if (isMounted)
+                            updateLastMessage(update);
+                    },
+                    updateMessageByToolId: (toolId, update) => {
+                        if (isMounted)
+                            updateMessageByToolId(toolId, update);
+                    },
+                    updateStats: (stats) => {
+                        if (isMounted)
+                            updateStats(stats);
+                    },
+                    setTodos: (todos) => {
+                        if (isMounted)
+                            setTodos(todos);
+                    },
+                    // Note: onComplete is now called after agent.run() returns
+                    // to capture the providerSessionId from the result
+                    onComplete: () => { },
+                }, apiClient, sessionId, config.verbose);
+                // Build mode-specific configuration
+                // Plan mode uses planSystemPrompt and restricts to read-only tools
+                const runConfig = {
+                    ...config,
+                    mode: agentMode,
+                    planFilePath,
+                    systemPromptAppend: agentMode === 'plan'
+                        ? envConfig.planSystemPrompt
+                        : config.systemPromptAppend,
+                };
+                // Run the agent through CoreAgent
+                // Store ref so we can abort from interrupt effect
+                const agent = new CoreAgent(presenter);
+                agentRef.current = agent;
+                const result = await agent.run(runConfig);
+                // Pass providerSessionId on completion for storage
+                if (isMounted) {
+                    onComplete(result.success, result.providerSessionId);
+                }
+            }
+            catch (error) {
+                if (isMounted) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    addMessage({
+                        type: "error",
+                        content: errorMessage,
+                        errorType: "error",
+                    });
+                    await apiClient.streamEvent(sessionId, {
+                        type: "session_error",
+                        error: errorMessage,
+                    });
+                    onComplete(false);
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setIsAgentRunning(false);
+                }
+            }
+        };
+        runAgent();
+        return () => {
+            isMounted = false;
+            agentRef.current = null;
+        };
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    return null; // This component doesn't render anything
+};
+/**
+ * Content component for InteractiveApp that has access to SessionContext
+ */
+const InteractiveAppContent = ({ config, sessionId: initialSessionId, webUrl, apiClient, onExit }) => {
+    const { addMessage, loadMessages, setSessionId: setContextSessionId, updateStats, } = useSession();
+    const [sessionId, setSessionId] = React.useState(initialSessionId);
+    const [currentTask, setCurrentTask] = React.useState(config.task);
+    const [taskId, setTaskId] = React.useState(0);
+    const [shouldRunAgent, setShouldRunAgent] = React.useState(!!config.task);
+    const [taskQueue, setTaskQueue] = React.useState([]);
+    // Track provider session ID for resume capability
+    const [providerSessionId, setProviderSessionId] = React.useState();
+    // Track initial tokens for resumed sessions
+    const [initialTokens, setInitialTokens] = React.useState(0);
+    const handleSubmitTask = async (task) => {
+        // Create session on first message if it doesn't exist
+        if (!sessionId) {
+            try {
+                const truncatedTitle = task.length > 50 ? task.slice(0, 50) + "..." : task;
+                const session = await apiClient.createSession(truncatedTitle, {
+                    cliVersion: CLI_VERSION,
+                    cwd: config.cwd || process.cwd(),
+                });
+                setSessionId(session.sessionId);
+                setContextSessionId(session.sessionId);
+            }
+            catch (error) {
+                const errorMessage = error instanceof ApiError
+                    ? error.message
+                    : `Failed to create session: ${error instanceof Error ? error.message : String(error)}`;
+                addMessage({
+                    type: "error",
+                    content: errorMessage,
+                    errorType: error instanceof ApiError && error.isAuthError ? "warning" : "error",
+                });
+                return;
+            }
+        }
+        if (shouldRunAgent) {
+            setTaskQueue((prev) => [...prev, task]);
+        }
+        else {
+            setCurrentTask(task);
+            addMessage({
+                type: "user",
+                content: task,
+            });
+            setTaskId((prev) => prev + 1);
+            setShouldRunAgent(true);
+        }
+    };
+    const handleAgentComplete = async (_success, newProviderSessionId) => {
+        setShouldRunAgent(false);
+        // Store the provider session ID for future resume capability
+        if (sessionId && newProviderSessionId && newProviderSessionId !== providerSessionId) {
+            setProviderSessionId(newProviderSessionId);
+            try {
+                await apiClient.updateSession(sessionId, {
+                    providerSessionId: newProviderSessionId,
+                });
+            }
+            catch {
+                // Non-critical - session will work without resume capability
+            }
+        }
+    };
+    // Process queued tasks when agent becomes idle
+    React.useEffect(() => {
+        if (!shouldRunAgent && taskQueue.length > 0) {
+            const [nextTask, ...remaining] = taskQueue;
+            setTaskQueue(remaining);
+            setCurrentTask(nextTask);
+            addMessage({
+                type: "user",
+                content: nextTask,
+            });
+            setTaskId((prev) => prev + 1);
+            setShouldRunAgent(true);
+        }
+    }, [shouldRunAgent, taskQueue, addMessage]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(App, { apiClient: apiClient, config: { ...config, task: currentTask }, onExit: onExit, onResumeSession: async (session) => {
+                try {
+                    if (!apiClient) {
+                        addMessage({
+                            type: "error",
+                            content: "API client not available. Cannot resume session.",
+                            errorType: "error",
+                        });
+                        return;
+                    }
+                    const response = await apiClient.getSessionMessages(session.id);
+                    const apiMessages = response.messages;
+                    // First pass: collect all tool_results by tool_use_id
+                    const toolResults = new Map();
+                    for (const msg of apiMessages) {
+                        const contentBlocks = msg.content;
+                        if (!contentBlocks)
+                            continue;
+                        for (const block of contentBlocks) {
+                            if (block.type === "tool_result" && block.tool_use_id) {
+                                // Extract text content from tool result
+                                let resultText = "";
+                                if (typeof block.content === "string") {
+                                    resultText = block.content;
+                                }
+                                else if (Array.isArray(block.content)) {
+                                    resultText = block.content
+                                        .map((c) => c.text || "")
+                                        .join("\n");
+                                }
+                                toolResults.set(block.tool_use_id, resultText);
+                            }
+                        }
+                    }
+                    // Convert API messages to UI Message format
+                    const uiMessages = apiMessages.flatMap((msg) => {
+                        const messages = [];
+                        const contentBlocks = msg.content;
+                        if (!contentBlocks || contentBlocks.length === 0) {
+                            return [];
+                        }
+                        for (const block of contentBlocks) {
+                            if (block.type === "text") {
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: msg.role,
+                                    content: block.text,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                            else if (block.type === "thinking") {
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: "thinking",
+                                    content: block.thinking,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                            else if (block.type === "tool_use") {
+                                // Look up the tool result for this tool_use
+                                const toolResult = toolResults.get(block.id);
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: "tool",
+                                    content: getToolDescription(block.name, block.input),
+                                    toolName: block.name,
+                                    toolInput: block.input,
+                                    toolResult: toolResult,
+                                    toolUseId: block.id,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                        }
+                        return messages;
+                    });
+                    setSessionId(session.id);
+                    setContextSessionId(session.id);
+                    // Set the provider session ID for resume capability
+                    // The session object may have providerSessionId from the API
+                    if (session.providerSessionId) {
+                        setProviderSessionId(session.providerSessionId);
+                    }
+                    // Fetch session details to get totalTokens for resume
+                    try {
+                        const sessionDetails = await apiClient.getSession(session.id);
+                        if (sessionDetails.totalTokens) {
+                            setInitialTokens(sessionDetails.totalTokens);
+                            updateStats({ totalTokens: sessionDetails.totalTokens });
+                        }
+                    }
+                    catch {
+                        // Non-critical - stats will start from 0
+                    }
+                    uiMessages.push({
+                        id: `resume-info-${Date.now()}`,
+                        type: "error",
+                        content: `Resumed session: ${session.title || "Untitled"} (${apiMessages.length} messages loaded)`,
+                        errorType: "info",
+                        timestamp: Date.now(),
+                    });
+                    loadMessages(uiMessages);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof ApiError
+                        ? error.message
+                        : `Failed to resume session: ${error instanceof Error ? error.message : String(error)}`;
+                    addMessage({
+                        type: "error",
+                        content: errorMessage,
+                        errorType: error instanceof ApiError && error.isAuthError
+                            ? "warning"
+                            : "error",
+                    });
+                }
+            }, onSubmitTask: handleSubmitTask, queuedTasks: taskQueue, sessionId: sessionId, webUrl: webUrl }),
+        shouldRunAgent && currentTask && sessionId && (React.createElement(AgentRunner, { apiClient: apiClient, config: { ...config, task: currentTask, providerSessionId, initialTokens }, key: `${taskId}`, onComplete: handleAgentComplete, sessionId: sessionId }))));
+};
+/**
+ * Main wrapper component that combines UI and agent
+ */
+const InteractiveApp = (props) => {
+    useBracketedPaste();
+    return (React.createElement(KeypressProvider, null,
+        React.createElement(MouseProvider, { mouseEventsEnabled: true },
+            React.createElement(SessionProvider, null,
+                React.createElement(InteractiveAppContent, { ...props })))));
+};
+/**
+ * Run the interactive mode with Ink UI
+ */
+export async function runInteractive(config) {
+    let success = false;
+    let unmountFn = null;
+    let isExiting = false;
+    const cleanupStdio = patchStdio();
+    const gracefulExit = async (exitCode) => {
+        if (isExiting)
+            return;
+        isExiting = true;
+        disableMouseEvents();
+        cleanupStdio();
+        if (unmountFn) {
+            unmountFn();
+        }
+        process.exit(exitCode);
+    };
+    const handleSigInt = async () => {
+        await gracefulExit(0);
+    };
+    process.on("SIGINT", handleSigInt);
+    process.on("SIGTERM", handleSigInt);
+    const isDev = process.env.NODE_ENV === "development";
+    logger.enableFileLogging(isDev);
+    const apiUrl = config.supatestApiUrl || "https://api.supatest.ai";
+    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
+    try {
+        process.stdout.write("\x1Bc");
+        console.clear();
+        enableMouseEvents();
+        const { stdout: inkStdout, stderr: inkStderr } = createInkStdio();
+        let sessionId;
+        let webUrl;
+        if (config.task) {
+            const truncatedTitle = config.task.length > 50 ? config.task.slice(0, 50) + "..." : config.task;
+            const session = await apiClient.createSession(truncatedTitle, {
+                cliVersion: CLI_VERSION,
+                cwd: config.cwd || process.cwd(),
+            });
+            sessionId = session.sessionId;
+            webUrl = session.webUrl;
+        }
+        const { unmount, waitUntilExit } = render(React.createElement(InteractiveApp, { apiClient: apiClient, config: config, onExit: (exitSuccess) => {
+                success = exitSuccess;
+            }, sessionId: sessionId, webUrl: webUrl }), {
+            stdout: inkStdout,
+            stderr: inkStderr,
+            stdin: process.stdin,
+            alternateBuffer: true,
+            exitOnCtrlC: false,
+        });
+        unmountFn = unmount;
+        await waitUntilExit();
+        unmount();
+        disableMouseEvents();
+        cleanupStdio();
+        process.off("SIGINT", handleSigInt);
+        process.off("SIGTERM", handleSigInt);
+        process.exit(success ? 0 : 1);
+    }
+    catch (error) {
+        disableMouseEvents();
+        cleanupStdio();
+        process.off("SIGINT", handleSigInt);
+        process.off("SIGTERM", handleSigInt);
+        console.error("Failed to start interactive mode:", error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/presenters/composite.js

@@ -0,0 +1,32 @@
+export class CompositePresenter {
+    presenters;
+    constructor(presenters) {
+        this.presenters = presenters;
+    }
+    async onStart(config) {
+        await Promise.all(this.presenters.map((p) => p.onStart(config)));
+    }
+    onLog(message) {
+        for (const p of this.presenters) {
+            p.onLog(message);
+        }
+    }
+    async onAssistantText(text) {
+        await Promise.all(this.presenters.map((p) => p.onAssistantText(text)));
+    }
+    async onThinking(text) {
+        await Promise.all(this.presenters.map((p) => p.onThinking(text)));
+    }
+    async onToolUse(tool, input, toolId) {
+        await Promise.all(this.presenters.map((p) => p.onToolUse(tool, input, toolId)));
+    }
+    async onTurnComplete(content) {
+        await Promise.all(this.presenters.map((p) => p.onTurnComplete(content)));
+    }
+    async onError(error) {
+        await Promise.all(this.presenters.map((p) => p.onError(error)));
+    }
+    async onComplete(result) {
+        await Promise.all(this.presenters.map((p) => p.onComplete(result)));
+    }
+}

package/dist/presenters/console.js

@@ -0,0 +1,163 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getToolDisplayName } from "shared";
+import { logger } from "../utils/logger";
+import { generateSummary } from "../utils/summary";
+// Fun spinner messages that rotate randomly
+const SPINNER_MESSAGES = [
+    "Brainstorming...",
+    "Brewing coffee...",
+    "Sipping espresso...",
+    "Testing theories...",
+    "Making magic...",
+    "Multiplying matrices...",
+];
+function getRandomSpinnerMessage() {
+    return SPINNER_MESSAGES[Math.floor(Math.random() * SPINNER_MESSAGES.length)];
+}
+function createShimmerFrames(text) {
+    const frames = [];
+    const baseText = text;
+    const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    for (let i = 0; i <= baseText.length; i++) {
+        const spinnerIcon = spinnerFrames[i % spinnerFrames.length];
+        const before = chalk.white(baseText.slice(0, i));
+        const current = baseText[i] || "";
+        const after = chalk.white(baseText.slice(i + 1));
+        const shimmerText = before + chalk.cyan.bold(current) + after;
+        frames.push(`${chalk.cyan(spinnerIcon)} ${shimmerText}`);
+    }
+    return frames;
+}
+export class ConsolePresenter {
+    spinner = null;
+    verbose;
+    stats;
+    constructor(options) {
+        this.verbose = options.verbose;
+        this.stats = {
+            startTime: Date.now(),
+            iterations: 0,
+            filesModified: new Set(),
+            commandsRun: [],
+            errors: [],
+        };
+        logger.setVerbose(options.verbose);
+    }
+    onStart(config) {
+        logger.raw("");
+        logger.raw(chalk.white.bold("Task:") + " " + chalk.cyan(config.task));
+        if (config.logs) {
+            logger.info("Processing provided logs...");
+        }
+        logger.raw("");
+        this.startSpinner();
+    }
+    onLog(message) {
+        if (this.verbose) {
+            this.stopSpinner();
+            logger.debug(message);
+            this.startSpinner();
+        }
+    }
+    onAssistantText(text) {
+        this.stopSpinner();
+        logger.raw(text);
+        this.startSpinner();
+    }
+    onThinking(text) {
+        if (this.verbose) {
+            this.stopSpinner();
+            logger.debug(`Thinking: ${text}`);
+            this.startSpinner();
+        }
+    }
+    onToolUse(tool, input, _toolId) {
+        if (this.spinner) {
+            const displayName = getToolDisplayName(tool);
+            this.spinner.text = `Using ${displayName}...`;
+        }
+        this.stopSpinner();
+        if (tool === "Read") {
+            logger.toolRead(input?.file_path || "file");
+        }
+        else if (tool === "Write") {
+            const filePath = input?.file_path;
+            if (filePath) {
+                this.stats.filesModified.add(filePath);
+                logger.toolWrite(filePath);
+            }
+        }
+        else if (tool === "Edit") {
+            const filePath = input?.file_path;
+            if (filePath) {
+                this.stats.filesModified.add(filePath);
+                logger.toolEdit(filePath);
+            }
+        }
+        else if (tool === "Bash") {
+            const command = input?.command;
+            if (command) {
+                this.stats.commandsRun.push(command);
+                const shortCmd = command.length > 60 ? `${command.substring(0, 60)}...` : command;
+                logger.toolBash(shortCmd);
+            }
+        }
+        else if (tool === "Glob") {
+            logger.toolSearch("files", input?.pattern || "");
+        }
+        else if (tool === "Grep") {
+            logger.toolSearch("code", input?.pattern || "");
+        }
+        else if (tool === "Task") {
+            logger.toolAgent(input?.subagent_type || "task");
+        }
+        else if (tool === "TodoWrite") {
+            const todos = input?.todos;
+            if (Array.isArray(todos)) {
+                logger.todoUpdate(todos);
+            }
+            else {
+                logger.info("📝 Updated todos");
+            }
+        }
+        else {
+            logger.debug(`🔧 Using tool: ${tool}`);
+        }
+        logger.raw("");
+        this.startSpinner();
+    }
+    onTurnComplete(_content) {
+        // No-op for console - we handle output in individual callbacks
+    }
+    onError(error) {
+        this.stopSpinner();
+        logger.error(error);
+        this.stats.errors.push(error);
+    }
+    onComplete(result) {
+        this.stopSpinner();
+        this.stats.endTime = Date.now();
+        this.stats.iterations = result.iterations;
+        const summaryText = generateSummary(this.stats, result, this.verbose);
+        logger.raw(summaryText);
+    }
+    startSpinner() {
+        if (!this.spinner && !logger.isSilent()) {
+            const message = getRandomSpinnerMessage();
+            this.spinner = ora({
+                spinner: {
+                    interval: 80,
+                    frames: createShimmerFrames(message),
+                },
+            });
+            this.spinner.start();
+        }
+    }
+    stopSpinner() {
+        if (this.spinner) {
+            this.spinner.stop();
+            this.spinner = null;
+        }
+    }
+}