@supatest/cli 0.0.3 → 0.0.4

package/dist/modes/interactive.js

@@ -1,430 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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;
-        }
-    }
-}