@supatest/cli 0.0.4 → 0.0.5

package/dist/ui/contexts/SessionContext.js

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * @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;
+}