@supatest/cli 0.0.5 → 0.0.6

package/dist/ui/contexts/SessionContext.js

@@ -1,129 +0,0 @@
-/**
- * Session Context
- * Manages the state of the interactive session including messages, todos, and agent status
- */
-import React, { createContext, useCallback, useContext, useState } from "react";
-const SessionContext = createContext(null);
-export const SessionProvider = ({ children, }) => {
-    const [messages, setMessages] = useState([]);
-    const [todos, setTodos] = useState([]);
-    const [stats, setStats] = useState({
-        filesModified: new Set(),
-        commandsRun: [],
-        iterations: 0,
-        startTime: Date.now(),
-    });
-    const [isAgentRunning, setIsAgentRunning] = useState(false);
-    const [shouldInterruptAgent, setShouldInterruptAgent] = useState(false);
-    const [sessionId, setSessionId] = useState();
-    const [webUrl, setWebUrl] = useState();
-    const [agentMode, setAgentMode] = useState('build');
-    const [planFilePath, setPlanFilePath] = useState();
-    const [allToolsExpanded, setAllToolsExpanded] = useState(true);
-    const addMessage = useCallback((message) => {
-        // Tools that support expand/collapse
-        const expandableTools = ["Bash", "BashOutput", "Command Output"];
-        const isExpandableTool = message.type === "tool" && expandableTools.includes(message.toolName || "");
-        const newMessage = {
-            ...message,
-            id: `${Date.now()}-${Math.random()}`,
-            timestamp: Date.now(),
-            // Set isExpanded based on current allToolsExpanded state for expandable tools
-            isExpanded: isExpandableTool ? allToolsExpanded : message.isExpanded,
-        };
-        setMessages((prev) => [...prev, newMessage]);
-    }, [allToolsExpanded]);
-    const updateLastMessage = useCallback((updates) => {
-        setMessages((prev) => {
-            if (prev.length === 0)
-                return prev;
-            const last = prev[prev.length - 1];
-            return [...prev.slice(0, -1), { ...last, ...updates }];
-        });
-    }, []);
-    const updateMessageById = useCallback((id, updates) => {
-        setMessages((prev) => {
-            const index = prev.findIndex((msg) => msg.id === id);
-            if (index === -1)
-                return prev;
-            const updated = [...prev];
-            updated[index] = { ...updated[index], ...updates };
-            return updated;
-        });
-    }, []);
-    const updateMessageByToolId = useCallback((toolId, updates) => {
-        setMessages((prev) => {
-            const index = prev.findIndex((msg) => msg.toolUseId === toolId);
-            if (index === -1)
-                return prev;
-            const updated = [...prev];
-            updated[index] = { ...updated[index], ...updates };
-            return updated;
-        });
-    }, []);
-    const clearMessages = useCallback(() => {
-        setMessages([]);
-        setTodos([]);
-        setStats({
-            filesModified: new Set(),
-            commandsRun: [],
-            iterations: 0,
-            startTime: Date.now(),
-        });
-        // Clear the terminal screen (similar to Gemini CLI behavior)
-        console.clear();
-    }, []);
-    const loadMessages = useCallback((newMessages) => {
-        setMessages(newMessages);
-    }, []);
-    const updateStats = useCallback((updates) => {
-        setStats((prev) => ({ ...prev, ...updates }));
-    }, []);
-    const toggleAllToolOutputs = useCallback(() => {
-        setAllToolsExpanded((prev) => {
-            const newValue = !prev;
-            // Update only Bash tool messages to match the new expanded state
-            // Other tools (Grep, Glob, Read, etc.) don't have expandable output
-            const expandableTools = ["Bash", "BashOutput", "Command Output"];
-            setMessages((msgs) => msgs.map((msg) => msg.type === "tool" && msg.toolResult && expandableTools.includes(msg.toolName || "")
-                ? { ...msg, isExpanded: newValue }
-                : msg));
-            return newValue;
-        });
-    }, []);
-    const value = {
-        messages,
-        addMessage,
-        updateLastMessage,
-        updateMessageById,
-        updateMessageByToolId,
-        clearMessages,
-        loadMessages,
-        toggleAllToolOutputs,
-        allToolsExpanded,
-        todos,
-        setTodos,
-        stats,
-        updateStats,
-        isAgentRunning,
-        setIsAgentRunning,
-        shouldInterruptAgent,
-        setShouldInterruptAgent,
-        sessionId,
-        setSessionId,
-        webUrl,
-        setWebUrl,
-        agentMode,
-        setAgentMode,
-        planFilePath,
-        setPlanFilePath,
-    };
-    return (React.createElement(SessionContext.Provider, { value: value }, children));
-};
-export const useSession = () => {
-    const context = useContext(SessionContext);
-    if (!context) {
-        throw new Error("useSession must be used within SessionProvider");
-    }
-    return context;
-};

package/dist/ui/hooks/useAnimatedScrollbar.js

@@ -1,83 +0,0 @@
-/**
- * Animated scrollbar hook
- * Provides a thin, animated scrollbar that fades in/out on interaction
- */
-import { useCallback, useEffect, useRef, useState } from "react";
-export const useAnimatedScrollbar = (isFocused, scrollBy, options) => {
-    const [scrollbarColor, setScrollbarColor] = useState(options.unfocusedColor);
-    const colorRef = useRef(scrollbarColor);
-    colorRef.current = scrollbarColor;
-    const animationFrame = useRef(null);
-    const timeout = useRef(null);
-    const isAnimatingRef = useRef(false);
-    const cleanup = useCallback(() => {
-        if (animationFrame.current) {
-            clearInterval(animationFrame.current);
-            animationFrame.current = null;
-        }
-        if (timeout.current) {
-            clearTimeout(timeout.current);
-            timeout.current = null;
-        }
-        isAnimatingRef.current = false;
-    }, []);
-    const interpolateColor = useCallback((color1, color2, progress) => {
-        // Simple color interpolation
-        return progress < 0.5 ? color1 : color2;
-    }, []);
-    const flashScrollbar = useCallback(() => {
-        cleanup();
-        isAnimatingRef.current = true;
-        const fadeInDuration = 200;
-        const visibleDuration = 1000;
-        const fadeOutDuration = 300;
-        const focusedColor = options.focusedColor;
-        const unfocusedColor = options.unfocusedColor;
-        const startColor = colorRef.current;
-        // Phase 1: Fade In
-        let start = Date.now();
-        const animateFadeIn = () => {
-            const elapsed = Date.now() - start;
-            const progress = Math.max(0, Math.min(elapsed / fadeInDuration, 1));
-            setScrollbarColor(interpolateColor(startColor, focusedColor, progress));
-            if (progress === 1) {
-                if (animationFrame.current) {
-                    clearInterval(animationFrame.current);
-                    animationFrame.current = null;
-                }
-                // Phase 2: Wait
-                timeout.current = setTimeout(() => {
-                    // Phase 3: Fade Out
-                    start = Date.now();
-                    const animateFadeOut = () => {
-                        const elapsed = Date.now() - start;
-                        const progress = Math.max(0, Math.min(elapsed / fadeOutDuration, 1));
-                        setScrollbarColor(interpolateColor(focusedColor, unfocusedColor, progress));
-                        if (progress === 1) {
-                            cleanup();
-                        }
-                    };
-                    animationFrame.current = setInterval(animateFadeOut, 33);
-                }, visibleDuration);
-            }
-        };
-        animationFrame.current = setInterval(animateFadeIn, 33);
-    }, [cleanup, interpolateColor, options.focusedColor, options.unfocusedColor]);
-    const wasFocused = useRef(isFocused);
-    useEffect(() => {
-        if (isFocused && !wasFocused.current) {
-            flashScrollbar();
-        }
-        else if (!isFocused && wasFocused.current) {
-            cleanup();
-            setScrollbarColor(options.unfocusedColor);
-        }
-        wasFocused.current = isFocused;
-        return cleanup;
-    }, [isFocused, flashScrollbar, cleanup, options.unfocusedColor]);
-    const scrollByWithAnimation = useCallback((delta) => {
-        scrollBy(delta);
-        flashScrollbar();
-    }, [scrollBy, flashScrollbar]);
-    return { scrollbarColor, flashScrollbar, scrollByWithAnimation };
-};

package/dist/ui/hooks/useBatchedScroll.js

@@ -1,22 +0,0 @@
-/**
- * Batched scroll hook
- * Batches scroll updates to prevent jittery behavior
- */
-import { useCallback, useRef } from "react";
-export const useBatchedScroll = (scrollTop) => {
-    const pendingScrollTopRef = useRef(null);
-    const currentScrollTopRef = useRef(scrollTop);
-    // Update current scroll top whenever it changes
-    currentScrollTopRef.current = scrollTop;
-    const getScrollTop = useCallback(() => {
-        return pendingScrollTopRef.current ?? currentScrollTopRef.current;
-    }, []);
-    const setPendingScrollTop = useCallback((value) => {
-        pendingScrollTopRef.current = value;
-        // Clear pending after a microtask
-        setTimeout(() => {
-            pendingScrollTopRef.current = null;
-        }, 0);
-    }, []);
-    return { getScrollTop, setPendingScrollTop };
-};

package/dist/ui/hooks/useBracketedPaste.js

@@ -1,31 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { useEffect } from 'react';
-import { writeToStdout } from '../../utils/stdio';
-const ENABLE_BRACKETED_PASTE = '\x1b[?2004h';
-const DISABLE_BRACKETED_PASTE = '\x1b[?2004l';
-/**
- * Enables and disables bracketed paste mode in the terminal.
- *
- * This hook ensures that bracketed paste mode is enabled when the component
- * mounts and disabled when it unmounts or when the process exits.
- *
- * Bracketed paste mode wraps pasted text in special escape sequences
- * ([200~ and [201~) so we can distinguish between typed and pasted text.
- */
-export const useBracketedPaste = () => {
-    useEffect(() => {
-        writeToStdout(ENABLE_BRACKETED_PASTE);
-        const cleanup = () => {
-            writeToStdout(DISABLE_BRACKETED_PASTE);
-        };
-        process.on('exit', cleanup);
-        return () => {
-            cleanup();
-            process.off('exit', cleanup);
-        };
-    }, []);
-};

package/dist/ui/hooks/useFocus.js

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { useStdin, useStdout } from 'ink';
-import { useEffect, useState } from 'react';
-import { useKeypress } from './useKeypress.js';
-// ANSI escape codes to enable/disable terminal focus reporting
-export const ENABLE_FOCUS_REPORTING = '\x1b[?1004h';
-export const DISABLE_FOCUS_REPORTING = '\x1b[?1004l';
-// ANSI escape codes for focus events
-export const FOCUS_IN = '\x1b[I';
-export const FOCUS_OUT = '\x1b[O';
-export const useFocus = () => {
-    const { stdin } = useStdin();
-    const { stdout } = useStdout();
-    const [isFocused, setIsFocused] = useState(true);
-    useEffect(() => {
-        const handleData = (data) => {
-            const sequence = data.toString();
-            const lastFocusIn = sequence.lastIndexOf(FOCUS_IN);
-            const lastFocusOut = sequence.lastIndexOf(FOCUS_OUT);
-            if (lastFocusIn > lastFocusOut) {
-                setIsFocused(true);
-            }
-            else if (lastFocusOut > lastFocusIn) {
-                setIsFocused(false);
-            }
-        };
-        // Enable focus reporting
-        stdout?.write(ENABLE_FOCUS_REPORTING);
-        stdin?.on('data', handleData);
-        return () => {
-            // Disable focus reporting on cleanup
-            stdout?.write(DISABLE_FOCUS_REPORTING);
-            stdin?.removeListener('data', handleData);
-        };
-    }, [stdin, stdout]);
-    useKeypress((_) => {
-        if (!isFocused) {
-            // If the user has typed a key, and we cannot possibly be focused out.
-            // This is a workaround for some tmux use cases. It is still useful to
-            // listen for the true FOCUS_IN event as well as that will update the
-            // focus state earlier than waiting for a keypress.
-            setIsFocused(true);
-        }
-    }, { isActive: true });
-    return isFocused;
-};

package/dist/ui/hooks/useKeypress.js

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { useEffect } from 'react';
-import { useKeypressContext } from '../contexts/KeypressContext';
-/**
- * A hook that listens for keypress events from stdin.
- *
- * @param onKeypress - The callback function to execute on each keypress.
- * @param options - Options to control the hook's behavior.
- * @param options.isActive - Whether the hook should be actively listening for input.
- */
-export function useKeypress(onKeypress, { isActive }) {
-    const { subscribe, unsubscribe } = useKeypressContext();
-    useEffect(() => {
-        if (!isActive) {
-            return;
-        }
-        subscribe(onKeypress);
-        return () => {
-            unsubscribe(onKeypress);
-        };
-    }, [isActive, onKeypress, subscribe, unsubscribe]);
-}

package/dist/ui/hooks/useModeToggle.js

@@ -1,25 +0,0 @@
-/**
- * Hook for toggling between plan and build modes
- * Uses Shift+Tab keyboard shortcut (like Claude Code)
- */
-import { useEffect } from "react";
-import { useKeypressContext } from "../contexts/KeypressContext.js";
-import { useSession } from "../contexts/SessionContext.js";
-export function useModeToggle() {
-    const { subscribe, unsubscribe } = useKeypressContext();
-    const { agentMode, setAgentMode, isAgentRunning } = useSession();
-    useEffect(() => {
-        const handleKeypress = (key) => {
-            // Shift+Tab to toggle mode (like Claude Code)
-            // Only allow toggling when agent is not running
-            if (key.name === "tab" && key.shift && !isAgentRunning) {
-                const newMode = agentMode === "plan" ? "build" : "plan";
-                setAgentMode(newMode);
-                // Mode indicator is shown below the input prompt (no message needed)
-            }
-        };
-        subscribe(handleKeypress);
-        return () => unsubscribe(handleKeypress);
-    }, [agentMode, isAgentRunning, setAgentMode, subscribe, unsubscribe]);
-    return { agentMode };
-}

package/dist/ui/types/auth.js

@@ -1,13 +0,0 @@
-/**
- * Auth types for Supatest CLI
- *
- * Based on Gemini CLI (Apache 2.0 License)
- * https://github.com/google-gemini/gemini-cli
- * Copyright 2025 Google LLC
- */
-export var AuthState;
-(function (AuthState) {
-    AuthState["Unauthenticated"] = "unauthenticated";
-    AuthState["Authenticating"] = "authenticating";
-    AuthState["Authenticated"] = "authenticated";
-})(AuthState || (AuthState = {}));

package/dist/ui/utils/file-completion.js

@@ -1,56 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-const IGNORED_DIRS = new Set([
-    'node_modules',
-    '.git',
-    '.turbo',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.cache'
-]);
-const IGNORED_EXTENSIONS = new Set([
-    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg',
-    '.woff', '.woff2', '.ttf', '.eot',
-    '.mp4', '.webm', '.mp3', '.wav',
-    '.zip', '.tar', '.gz', '.7z', '.rar',
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx',
-    '.exe', '.dll', '.so', '.dylib', '.bin',
-    '.map', '.lock', '.tsbuildinfo'
-]);
-function shouldIgnore(name, isDir) {
-    if (name.startsWith('.'))
-        return true; // Ignore dotfiles by default for now
-    if (isDir)
-        return IGNORED_DIRS.has(name);
-    const ext = path.extname(name).toLowerCase();
-    return IGNORED_EXTENSIONS.has(ext);
-}
-export function getFiles(rootDir = process.cwd(), maxDepth = 3) {
-    const files = [];
-    function scan(dir, depth) {
-        if (depth > maxDepth)
-            return;
-        try {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (shouldIgnore(entry.name, entry.isDirectory()))
-                    continue;
-                const fullPath = path.join(dir, entry.name);
-                const relativePath = path.relative(rootDir, fullPath);
-                if (entry.isDirectory()) {
-                    scan(fullPath, depth + 1);
-                }
-                else {
-                    files.push(relativePath);
-                }
-            }
-        }
-        catch (error) {
-            // Ignore access errors
-        }
-    }
-    scan(rootDir, 0);
-    return files;
-}

package/dist/ui/utils/input.js

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export const ESC = '\u001B';
-export const SGR_EVENT_PREFIX = `${ESC}[<`;
-export const X11_EVENT_PREFIX = `${ESC}[M`;
-// eslint-disable-next-line no-control-regex
-export const SGR_MOUSE_REGEX = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/; // SGR mouse events
-// X11 is ESC [ M followed by 3 bytes.
-// eslint-disable-next-line no-control-regex
-export const X11_MOUSE_REGEX = /^\x1b\[M([\s\S]{3})/;
-export function couldBeSGRMouseSequence(buffer) {
-    if (buffer.length === 0)
-        return true;
-    // Check if buffer is a prefix of a mouse sequence starter
-    if (SGR_EVENT_PREFIX.startsWith(buffer))
-        return true;
-    // Check if buffer is a mouse sequence prefix
-    if (buffer.startsWith(SGR_EVENT_PREFIX))
-        return true;
-    return false;
-}
-export function couldBeMouseSequence(buffer) {
-    if (buffer.length === 0)
-        return true;
-    // Check SGR prefix
-    if (SGR_EVENT_PREFIX.startsWith(buffer) ||
-        buffer.startsWith(SGR_EVENT_PREFIX))
-        return true;
-    // Check X11 prefix
-    if (X11_EVENT_PREFIX.startsWith(buffer) ||
-        buffer.startsWith(X11_EVENT_PREFIX))
-        return true;
-    return false;
-}
-/**
- * Checks if the buffer *starts* with a complete mouse sequence.
- * Returns the length of the sequence if matched, or 0 if not.
- */
-export function getMouseSequenceLength(buffer) {
-    const sgrMatch = buffer.match(SGR_MOUSE_REGEX);
-    if (sgrMatch)
-        return sgrMatch[0].length;
-    const x11Match = buffer.match(X11_MOUSE_REGEX);
-    if (x11Match)
-        return x11Match[0].length;
-    return 0;
-}