@supatest/cli 0.0.5 → 0.0.7

package/dist/ui/utils/markdown.js

@@ -1,376 +0,0 @@
-/**
- * Markdown rendering for terminal UI
- * Custom implementation with improved table rendering, code block syntax highlighting,
- * and full theme integration
- */
-import chalk from "chalk";
-import { Box, Text } from "ink";
-import { all, createLowlight } from "lowlight";
-import React, { useMemo } from "react";
-import { theme } from "./theme.js";
-const lowlight = createLowlight(all);
-/**
- * Parse markdown and extract tables, code blocks, and text sections
- */
-function parseMarkdownSections(text) {
-    const sections = [];
-    const lines = text.split(/\r?\n/);
-    let currentTextSection = "";
-    let inCodeBlock = false;
-    let codeBlockLanguage = "";
-    let codeBlockLines = [];
-    let inTable = false;
-    let tableRows = [];
-    const flushTextSection = () => {
-        if (currentTextSection.trim()) {
-            sections.push({
-                type: "text",
-                content: currentTextSection.trim(),
-            });
-            currentTextSection = "";
-        }
-    };
-    const flushCodeBlock = () => {
-        if (codeBlockLines.length > 0) {
-            flushTextSection();
-            sections.push({
-                type: "code",
-                content: codeBlockLines.join("\n"),
-                codeLanguage: codeBlockLanguage,
-            });
-            codeBlockLines = [];
-            codeBlockLanguage = "";
-        }
-    };
-    const flushTable = () => {
-        if (tableRows.length > 0) {
-            flushTextSection();
-            sections.push({
-                type: "table",
-                content: "",
-                tableRows: [...tableRows],
-            });
-            tableRows = [];
-        }
-    };
-    for (const line of lines) {
-        // Code fence detection
-        const codeFenceMatch = line.match(/^```(\w*)/);
-        if (codeFenceMatch) {
-            if (!inCodeBlock) {
-                flushTextSection();
-                flushTable();
-                inCodeBlock = true;
-                codeBlockLanguage = codeFenceMatch[1] || "";
-            }
-            else {
-                inCodeBlock = false;
-                flushCodeBlock();
-            }
-            continue;
-        }
-        // Inside code block
-        if (inCodeBlock) {
-            codeBlockLines.push(line);
-            continue;
-        }
-        // Table detection
-        const trimmedLine = line.trim();
-        const isTableRow = trimmedLine.match(/^\|.+\|$/);
-        const isTableSeparator = trimmedLine.match(/^\|[\s\-:]+\|$/) && trimmedLine.includes("-");
-        if (isTableRow || isTableSeparator) {
-            if (!inTable) {
-                flushTextSection();
-                inTable = true;
-            }
-            // Skip separator rows
-            if (!isTableSeparator) {
-                tableRows.push(line);
-            }
-            continue;
-        }
-        // End of table
-        if (inTable) {
-            flushTable();
-            inTable = false;
-        }
-        // Regular text
-        if (currentTextSection) {
-            currentTextSection += "\n" + line;
-        }
-        else {
-            currentTextSection = line;
-        }
-    }
-    // Flush any remaining sections
-    if (inCodeBlock) {
-        flushCodeBlock();
-    }
-    if (inTable) {
-        flushTable();
-    }
-    flushTextSection();
-    return sections;
-}
-/**
- * Parse and render markdown text for terminal display
- */
-export const MarkdownDisplay = ({ text, isPending = false, terminalWidth = 80, }) => {
-    const sections = useMemo(() => parseMarkdownSections(text), [text]);
-    const elements = sections.map((section, index) => {
-        if (section.type === "table" && section.tableRows) {
-            return (React.createElement(Table, { key: `table-${index}`, rows: section.tableRows }));
-        }
-        if (section.type === "code") {
-            return (React.createElement(CodeBlock, { code: section.content, key: `code-${index}`, language: section.codeLanguage || "" }));
-        }
-        // Render text sections with custom markdown parser
-        return (React.createElement(TextSection, { content: section.content, key: `text-${index}` }));
-    });
-    // Add cursor for pending state
-    if (isPending) {
-        elements.push(React.createElement(Text, { color: theme.text.accent, key: "cursor" }, "\u258A"));
-    }
-    return React.createElement(Box, { flexDirection: "column" }, elements);
-};
-/**
- * Render text section with markdown formatting
- */
-const TextSection = ({ content }) => {
-    const lines = content.split(/\r?\n/);
-    const elements = [];
-    let lineIndex = 0;
-    for (const line of lines) {
-        lineIndex++;
-        // Header detection (# H1, ## H2, etc.)
-        const headerMatch = line.match(/^(#{1,6})\s+(.+)/);
-        if (headerMatch) {
-            const level = headerMatch[1].length;
-            const content = headerMatch[2];
-            elements.push(React.createElement(Header, { content: content, key: `header-${lineIndex}`, level: level }));
-            continue;
-        }
-        // List item detection (- item or * item or 1. item)
-        const listMatch = line.match(/^(\s*)([-*]|\d+\.)\s+(.+)/);
-        if (listMatch) {
-            const indent = listMatch[1].length;
-            const marker = listMatch[2];
-            const content = listMatch[3];
-            elements.push(React.createElement(ListItem, { content: content, indent: indent, key: `list-${lineIndex}`, marker: marker }));
-            continue;
-        }
-        // Horizontal rule
-        if (line.match(/^-{3,}$/)) {
-            elements.push(React.createElement(HorizontalRule, { key: `hr-${lineIndex}` }));
-            continue;
-        }
-        // Regular paragraph with inline formatting
-        if (line.trim()) {
-            elements.push(React.createElement(Paragraph, { content: line, key: `para-${lineIndex}` }));
-        }
-        else {
-            // Empty line
-            elements.push(React.createElement(Text, { key: `empty-${lineIndex}` }, "\n"));
-        }
-    }
-    return React.createElement(Box, { flexDirection: "column" }, elements);
-};
-/**
- * Render a header (h1-h6)
- */
-const Header = ({ level, content, }) => {
-    const colors = [
-        theme.text.accent, // H1
-        theme.text.accent, // H2
-        theme.text.primary, // H3
-        theme.text.secondary, // H4
-        theme.text.secondary, // H5
-        theme.text.dim, // H6
-    ];
-    const color = colors[level - 1] || theme.text.primary;
-    const bold = level <= 2;
-    return (React.createElement(Text, { bold: bold, color: color },
-        content,
-        "\n"));
-};
-/**
- * Render a list item
- */
-const ListItem = ({ indent, marker, content }) => {
-    const formattedContent = formatInline(content);
-    const indentStr = " ".repeat(indent);
-    return (React.createElement(Text, null,
-        indentStr,
-        React.createElement(Text, { color: theme.text.accent }, marker),
-        " ",
-        formattedContent,
-        "\n"));
-};
-/**
- * Render a horizontal rule
- */
-const HorizontalRule = () => {
-    return (React.createElement(Text, { color: theme.border.default },
-        "─".repeat(60),
-        "\n"));
-};
-/**
- * Render a paragraph with inline formatting
- */
-const Paragraph = ({ content }) => {
-    const formattedContent = formatInline(content);
-    return (React.createElement(Text, null,
-        formattedContent,
-        "\n"));
-};
-/**
- * Format inline markdown (bold, italic, inline code, links)
- */
-function formatInline(text) {
-    let result = text;
-    // Inline code: `code`
-    result = result.replace(/`([^`]+)`/g, (_, code) => {
-        return chalk.cyan(code);
-    });
-    // Bold: **text** or __text__
-    result = result.replace(/(\*\*|__)([^*_]+)\1/g, (_, __, text) => {
-        return chalk.bold(text);
-    });
-    // Italic: *text* or _text_ (but not **, __, or inside words)
-    result = result.replace(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g, (_, text) => {
-        return chalk.italic(text);
-    });
-    // Links: [text](url) - show as underlined cyan text
-    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text) => {
-        return chalk.cyan.underline(text);
-    });
-    return result;
-}
-/**
- * Render a markdown table with improved formatting
- */
-const Table = ({ rows }) => {
-    if (rows.length === 0) {
-        return null;
-    }
-    // Parse all rows to extract cells
-    const parsedRows = rows.map((row) => {
-        const cells = row
-            .trim()
-            .replace(/^\||\|$/g, "")
-            .split("|")
-            .map((cell) => cell.trim());
-        return cells;
-    });
-    if (parsedRows.length === 0) {
-        return null;
-    }
-    // Determine column widths (calculate based on actual content length)
-    const numColumns = parsedRows[0]?.length || 0;
-    const columnWidths = [];
-    for (let col = 0; col < numColumns; col++) {
-        let maxWidth = 0;
-        for (const row of parsedRows) {
-            const cellContent = row[col] || "";
-            // Strip ANSI codes for width calculation
-            const plainText = cellContent.replace(/\u001b\[[0-9;]*m/g, "");
-            const width = plainText.length;
-            maxWidth = Math.max(maxWidth, width);
-        }
-        columnWidths.push(Math.max(maxWidth, 3)); // Minimum width of 3
-    }
-    // Build formatted table as text with better visual separation
-    const tableLines = [];
-    // Header row (first row)
-    if (parsedRows.length > 0) {
-        const headerRow = parsedRows[0];
-        const headerCells = headerRow.map((cell, colIndex) => {
-            const formatted = formatInline(cell);
-            const width = columnWidths[colIndex] || 10;
-            return formatted.padEnd(width);
-        });
-        tableLines.push(chalk.hex(theme.text.accent).bold(headerCells.join(" │ ")));
-        // Separator line with better visual design
-        const separator = columnWidths
-            .map((width) => "─".repeat(width))
-            .join("─┼─");
-        tableLines.push(chalk.hex(theme.border.default)(separator));
-        // Data rows
-        for (let rowIndex = 1; rowIndex < parsedRows.length; rowIndex++) {
-            const row = parsedRows[rowIndex];
-            const cells = row.map((cell, colIndex) => {
-                const formatted = formatInline(cell);
-                const width = columnWidths[colIndex] || 10;
-                return formatted.padEnd(width);
-            });
-            tableLines.push(cells.join(" │ "));
-        }
-    }
-    return (React.createElement(Text, null,
-        tableLines.join("\n"),
-        "\n"));
-};
-/**
- * Code block with syntax highlighting
- */
-const CodeBlock = ({ code, language, }) => {
-    // Try to highlight if language is specified
-    let highlighted = code;
-    if (language) {
-        try {
-            const result = lowlight.highlight(language, code);
-            highlighted = highlightTreeToString(result);
-        }
-        catch (error) {
-            // Language not supported, use plain text
-            highlighted = code;
-        }
-    }
-    return (React.createElement(Box, { borderColor: theme.border.default, borderStyle: "round", flexDirection: "column", marginY: 0, paddingX: 1 },
-        language && (React.createElement(Text, { color: theme.text.dim },
-            language,
-            "\n")),
-        React.createElement(Text, null, highlighted)));
-};
-/**
- * Convert lowlight AST to colored string
- */
-function highlightTreeToString(node) {
-    if (node.type === "text") {
-        return node.value;
-    }
-    if (node.type === "element") {
-        const className = node.properties?.className?.[0] || "";
-        let content = "";
-        if (node.children) {
-            content = node.children.map(highlightTreeToString).join("");
-        }
-        // Map token types to colors
-        if (className.includes("keyword")) {
-            return chalk.magenta(content);
-        }
-        if (className.includes("string")) {
-            return chalk.green(content);
-        }
-        if (className.includes("comment")) {
-            return chalk.gray(content);
-        }
-        if (className.includes("function")) {
-            return chalk.blue(content);
-        }
-        if (className.includes("number")) {
-            return chalk.cyan(content);
-        }
-        if (className.includes("operator")) {
-            return chalk.yellow(content);
-        }
-        if (className.includes("class-name") || className.includes("type")) {
-            return chalk.yellow(content);
-        }
-        return content;
-    }
-    if (Array.isArray(node)) {
-        return node.map(highlightTreeToString).join("");
-    }
-    return "";
-}

package/dist/ui/utils/mouse.js

@@ -1,189 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { writeToStdout } from '../../utils/stdio';
-import { couldBeMouseSequence as inputCouldBeMouseSequence, SGR_EVENT_PREFIX, SGR_MOUSE_REGEX, X11_EVENT_PREFIX, X11_MOUSE_REGEX, } from './input';
-export function getMouseEventName(buttonCode, isRelease) {
-    const isMove = (buttonCode & 32) !== 0;
-    if (buttonCode === 66) {
-        return 'scroll-left';
-    }
-    else if (buttonCode === 67) {
-        return 'scroll-right';
-    }
-    else if ((buttonCode & 64) === 64) {
-        if ((buttonCode & 1) === 0) {
-            return 'scroll-up';
-        }
-        else {
-            return 'scroll-down';
-        }
-    }
-    else if (isMove) {
-        return 'move';
-    }
-    else {
-        const button = buttonCode & 3;
-        const type = isRelease ? 'release' : 'press';
-        switch (button) {
-            case 0:
-                return `left-${type}`;
-            case 1:
-                return `middle-${type}`;
-            case 2:
-                return `right-${type}`;
-            default:
-                return null;
-        }
-    }
-}
-function getButtonFromCode(code) {
-    const button = code & 3;
-    switch (button) {
-        case 0:
-            return 'left';
-        case 1:
-            return 'middle';
-        case 2:
-            return 'right';
-        default:
-            return 'none';
-    }
-}
-export function parseSGRMouseEvent(buffer) {
-    const match = buffer.match(SGR_MOUSE_REGEX);
-    if (match) {
-        const buttonCode = parseInt(match[1], 10);
-        const col = parseInt(match[2], 10);
-        const row = parseInt(match[3], 10);
-        const action = match[4];
-        const isRelease = action === 'm';
-        const shift = (buttonCode & 4) !== 0;
-        const meta = (buttonCode & 8) !== 0;
-        const ctrl = (buttonCode & 16) !== 0;
-        const name = getMouseEventName(buttonCode, isRelease);
-        if (name) {
-            return {
-                event: {
-                    name,
-                    ctrl,
-                    meta,
-                    shift,
-                    col,
-                    row,
-                    button: getButtonFromCode(buttonCode),
-                },
-                length: match[0].length,
-            };
-        }
-        return null;
-    }
-    return null;
-}
-export function parseX11MouseEvent(buffer) {
-    const match = buffer.match(X11_MOUSE_REGEX);
-    if (!match)
-        return null;
-    // The 3 bytes are in match[1]
-    const b = match[1].charCodeAt(0) - 32;
-    const col = match[1].charCodeAt(1) - 32;
-    const row = match[1].charCodeAt(2) - 32;
-    const shift = (b & 4) !== 0;
-    const meta = (b & 8) !== 0;
-    const ctrl = (b & 16) !== 0;
-    const isMove = (b & 32) !== 0;
-    const isWheel = (b & 64) !== 0;
-    let name = null;
-    if (isWheel) {
-        const button = b & 3;
-        switch (button) {
-            case 0:
-                name = 'scroll-up';
-                break;
-            case 1:
-                name = 'scroll-down';
-                break;
-            default:
-                break;
-        }
-    }
-    else if (isMove) {
-        name = 'move';
-    }
-    else {
-        const button = b & 3;
-        if (button === 3) {
-            // X11 reports 'release' (3) for all button releases without specifying which one.
-            // We'll default to 'left-release' as a best-effort guess if we don't track state.
-            name = 'left-release';
-        }
-        else {
-            switch (button) {
-                case 0:
-                    name = 'left-press';
-                    break;
-                case 1:
-                    name = 'middle-press';
-                    break;
-                case 2:
-                    name = 'right-press';
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-    if (name) {
-        let button = getButtonFromCode(b);
-        if (name === 'left-release' && button === 'none') {
-            button = 'left';
-        }
-        return {
-            event: {
-                name,
-                ctrl,
-                meta,
-                shift,
-                col,
-                row,
-                button,
-            },
-            length: match[0].length,
-        };
-    }
-    return null;
-}
-export function parseMouseEvent(buffer) {
-    return parseSGRMouseEvent(buffer) || parseX11MouseEvent(buffer);
-}
-export function isIncompleteMouseSequence(buffer) {
-    if (!inputCouldBeMouseSequence(buffer))
-        return false;
-    // If it matches a complete sequence, it's not incomplete.
-    if (parseMouseEvent(buffer))
-        return false;
-    if (buffer.startsWith(X11_EVENT_PREFIX)) {
-        // X11 needs exactly 3 bytes after prefix.
-        return buffer.length < X11_EVENT_PREFIX.length + 3;
-    }
-    if (buffer.startsWith(SGR_EVENT_PREFIX)) {
-        // SGR sequences end with 'm' or 'M'.
-        // If it doesn't have it yet, it's incomplete.
-        // Add a reasonable max length check to fail early on garbage.
-        return !/[mM]/.test(buffer) && buffer.length < 50;
-    }
-    // It's a prefix of the prefix (e.g. "ESC" or "ESC [")
-    return true;
-}
-export function enableMouseEvents() {
-    // Enable mouse tracking with SGR format
-    // ?1002h = button event tracking (clicks + drags + scroll wheel)
-    // ?1006h = SGR extended mouse mode (better coordinate handling)
-    writeToStdout('\u001b[?1002h\u001b[?1006h');
-}
-export function disableMouseEvents() {
-    // Disable mouse tracking with SGR format
-    writeToStdout('\u001b[?1006l\u001b[?1002l');
-}

package/dist/ui/utils/theme.js

@@ -1,59 +0,0 @@
-/**
- * UI Theme for Supatest CLI
- * Defines colors and styling for the interactive terminal UI
- */
-export const theme = {
-    // Text colors
-    text: {
-        primary: "#FFFFFF",
-        secondary: "#A0AEC0",
-        dim: "#4A5568",
-        accent: "#38B2AC", // Cyan/teal accent
-        success: "#48BB78",
-        error: "#F56565",
-        warning: "#ED8936",
-        info: "#4299E1",
-    },
-    // Background colors (for boxed content)
-    bg: {
-        primary: "#1A202C",
-        secondary: "#2D3748",
-        accent: "#234E52",
-    },
-    // Borders
-    border: {
-        default: "#4A5568",
-        accent: "#38B2AC",
-        error: "#F56565",
-    },
-    // Tool/action colors
-    tool: {
-        read: "#4299E1", // Blue
-        write: "#48BB78", // Green
-        edit: "#ED8936", // Orange
-        bash: "#38B2AC", // Cyan
-        search: "#9F7AEA", // Purple
-        agent: "#ED64A6", // Pink
-    },
-    // Status colors
-    status: {
-        pending: "#A0AEC0",
-        inProgress: "#ED8936",
-        completed: "#48BB78",
-        failed: "#F56565",
-    },
-};
-/**
- * Get color value by path (e.g., 'text.primary', 'tool.read')
- */
-export function getThemeColor(path) {
-    const parts = path.split(".");
-    let current = theme;
-    for (const part of parts) {
-        if (current[part] === undefined) {
-            return theme.text.primary;
-        }
-        current = current[part];
-    }
-    return typeof current === "string" ? current : theme.text.primary;
-}

package/dist/utils/banner.js

@@ -1,9 +0,0 @@
-export function getBanner() {
-    const banner = `███████╗██╗   ██╗██████╗  █████╗ ████████╗███████╗███████╗████████╗
-██╔════╝██║   ██║██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝
-███████╗██║   ██║██████╔╝███████║   ██║   █████╗  ███████╗   ██║
-╚════██║██║   ██║██╔═══╝ ██╔══██║   ██║   ██╔══╝  ╚════██║   ██║
-███████║╚██████╔╝██║     ██║  ██║   ██║   ███████╗███████║   ██║
-╚══════╝ ╚═════╝ ╚═╝     ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝   ╚═╝`;
-    return banner;
-}

package/dist/utils/encryption.js

@@ -1,71 +0,0 @@
-/**
- * Token encryption utilities using AES-256-GCM with machine-specific key derivation.
- * Inspired by Gemini CLI's file-token-storage implementation.
- */
-import crypto from "node:crypto";
-import { hostname, userInfo } from "node:os";
-const ALGORITHM = "aes-256-gcm";
-const KEY_LENGTH = 32;
-const IV_LENGTH = 16;
-/**
- * Derive an encryption key from machine-specific identifiers.
- * Uses scrypt for key derivation with a salt based on hostname and username.
- * This means tokens encrypted on one machine cannot be decrypted on another.
- */
-function deriveEncryptionKey() {
-    const salt = `${hostname()}-${userInfo().username}-supatest-cli`;
-    return crypto.scryptSync("supatest-cli-token", salt, KEY_LENGTH);
-}
-// Cache the derived key for performance
-let cachedKey = null;
-function getEncryptionKey() {
-    if (!cachedKey) {
-        cachedKey = deriveEncryptionKey();
-    }
-    return cachedKey;
-}
-/**
- * Encrypt plaintext using AES-256-GCM with a machine-derived key.
- * Returns a colon-separated string: iv:authTag:ciphertext (all hex encoded)
- */
-export function encrypt(plaintext) {
-    const key = getEncryptionKey();
-    const iv = crypto.randomBytes(IV_LENGTH);
-    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
-    let encrypted = cipher.update(plaintext, "utf8", "hex");
-    encrypted += cipher.final("hex");
-    const authTag = cipher.getAuthTag();
-    return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
-}
-/**
- * Decrypt ciphertext that was encrypted with the encrypt() function.
- * Expects format: iv:authTag:ciphertext (all hex encoded)
- */
-export function decrypt(encryptedData) {
-    const parts = encryptedData.split(":");
-    if (parts.length !== 3) {
-        throw new Error("Invalid encrypted data format");
-    }
-    const [ivHex, authTagHex, encrypted] = parts;
-    const iv = Buffer.from(ivHex, "hex");
-    const authTag = Buffer.from(authTagHex, "hex");
-    const key = getEncryptionKey();
-    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
-    decipher.setAuthTag(authTag);
-    let decrypted = decipher.update(encrypted, "hex", "utf8");
-    decrypted += decipher.final("utf8");
-    return decrypted;
-}
-/**
- * Check if a string appears to be in the encrypted format.
- * Encrypted format has 3 hex segments separated by colons.
- */
-export function isEncrypted(data) {
-    const parts = data.split(":");
-    if (parts.length !== 3) {
-        return false;
-    }
-    // Check each part looks like valid hex
-    const hexRegex = /^[0-9a-fA-F]+$/;
-    return parts.every((p) => p.length > 0 && hexRegex.test(p));
-}