@supatest/cli 0.0.3 → 0.0.4

package/dist/utils/events.js

@@ -1,36 +0,0 @@
-/**
- * Simple event emitter for app-level events
- */
-export var AppEvent;
-(function (AppEvent) {
-    AppEvent["PasteTimeout"] = "paste-timeout";
-    AppEvent["OpenDebugConsole"] = "open-debug-console";
-    AppEvent["SelectionWarning"] = "selection-warning";
-})(AppEvent || (AppEvent = {}));
-class EventEmitter {
-    events = new Map();
-    on(event, callback) {
-        if (!this.events.has(event)) {
-            this.events.set(event, []);
-        }
-        this.events.get(event).push(callback);
-    }
-    emit(event, ...args) {
-        const callbacks = this.events.get(event);
-        if (callbacks) {
-            for (const callback of callbacks) {
-                callback(...args);
-            }
-        }
-    }
-    off(event, callback) {
-        const callbacks = this.events.get(event);
-        if (callbacks) {
-            const index = callbacks.indexOf(callback);
-            if (index > -1) {
-                callbacks.splice(index, 1);
-            }
-        }
-    }
-}
-export const appEvents = new EventEmitter();

package/dist/utils/keychain-storage.js

@@ -1,120 +0,0 @@
-/**
- * OS Keychain token storage using keytar.
- * Inspired by Gemini CLI's keychain-token-storage implementation.
- */
-import crypto from "node:crypto";
-const SERVICE_NAME = "supatest-cli";
-const ACCOUNT_NAME = "cli-token";
-const KEYCHAIN_TEST_PREFIX = "__keychain_test__";
-let keytarModule = null;
-let keytarLoadAttempted = false;
-let keychainAvailable = null;
-/**
- * Dynamically load the keytar module.
- * Returns null if keytar is not available (not installed or failed to load).
- */
-async function getKeytar() {
-    if (keytarLoadAttempted) {
-        return keytarModule;
-    }
-    keytarLoadAttempted = true;
-    try {
-        const moduleName = "keytar";
-        const mod = await import(moduleName);
-        keytarModule = mod.default || mod;
-    }
-    catch {
-        // Keytar is optional, so we silently fall back to file storage
-        keytarModule = null;
-    }
-    return keytarModule;
-}
-/**
- * Check if OS keychain is available via a set/get/delete test cycle.
- * Respects SUPATEST_FORCE_FILE_STORAGE environment variable.
- */
-export async function isKeychainAvailable() {
-    if (keychainAvailable !== null) {
-        return keychainAvailable;
-    }
-    if (process.env.SUPATEST_FORCE_FILE_STORAGE === "true") {
-        keychainAvailable = false;
-        return false;
-    }
-    try {
-        const keytar = await getKeytar();
-        if (!keytar) {
-            keychainAvailable = false;
-            return false;
-        }
-        // Test with a set/get/delete cycle
-        const testAccount = `${KEYCHAIN_TEST_PREFIX}${crypto.randomBytes(8).toString("hex")}`;
-        const testPassword = "test";
-        await keytar.setPassword(SERVICE_NAME, testAccount, testPassword);
-        const retrieved = await keytar.getPassword(SERVICE_NAME, testAccount);
-        const deleted = await keytar.deletePassword(SERVICE_NAME, testAccount);
-        keychainAvailable = deleted && retrieved === testPassword;
-    }
-    catch {
-        keychainAvailable = false;
-    }
-    return keychainAvailable;
-}
-/**
- * Save token payload to OS keychain.
- * Returns true if successful, false otherwise.
- */
-export async function saveToKeychain(token, expiresAt) {
-    const keytar = await getKeytar();
-    if (!keytar) {
-        return false;
-    }
-    const payload = {
-        token,
-        expiresAt,
-        createdAt: new Date().toISOString(),
-    };
-    try {
-        await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, JSON.stringify(payload));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Load token payload from OS keychain.
- * Returns null if not found or keychain unavailable.
- */
-export async function loadFromKeychain() {
-    const keytar = await getKeytar();
-    if (!keytar) {
-        return null;
-    }
-    try {
-        const data = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
-        if (!data) {
-            return null;
-        }
-        return JSON.parse(data);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Remove token from OS keychain.
- * Returns true if successfully removed, false otherwise.
- */
-export async function removeFromKeychain() {
-    const keytar = await getKeytar();
-    if (!keytar) {
-        return false;
-    }
-    try {
-        return await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
-    }
-    catch {
-        return false;
-    }
-}

package/dist/utils/logger.js

@@ -1,209 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import chalk from "chalk";
-class Logger {
-    verbose = false;
-    silent = false;
-    logFile = null;
-    isDev = false;
-    setVerbose(enabled) {
-        this.verbose = enabled;
-    }
-    setSilent(enabled) {
-        this.silent = enabled;
-    }
-    isSilent() {
-        return this.silent;
-    }
-    /**
-     * Enable file logging (dev mode only)
-     */
-    enableFileLogging(isDev = false) {
-        this.isDev = isDev;
-        if (!isDev)
-            return;
-        // Write directly to cli.log in current directory
-        this.logFile = path.join(process.cwd(), "cli.log");
-        // Add session separator to log file
-        const separator = `\n${"=".repeat(80)}\n[${new Date().toISOString()}] New CLI session started\n${"=".repeat(80)}\n`;
-        try {
-            fs.appendFileSync(this.logFile, separator);
-        }
-        catch (error) {
-            // Silently fail
-        }
-    }
-    /**
-     * Write to log file (dev mode only)
-     */
-    writeToFile(level, message, data) {
-        if (!this.isDev || !this.logFile)
-            return;
-        const timestamp = new Date().toISOString();
-        const logEntry = data
-            ? `[${timestamp}] [${level}] ${message} ${JSON.stringify(data, null, 2)}\n`
-            : `[${timestamp}] [${level}] ${message}\n`;
-        try {
-            fs.appendFileSync(this.logFile, logEntry);
-        }
-        catch (error) {
-            // Silently fail - don't disrupt CLI operation
-        }
-    }
-    /**
-     * Check if an error message is critical and should bypass silent mode
-     * Critical errors are those that prevent the CLI from starting or executing
-     */
-    isCriticalError(message) {
-        const criticalPatterns = [
-            /api key/i,
-            /authentication/i,
-            /node.*version/i,
-            /missing.*required/i,
-            /failed to install/i,
-            /fatal/i,
-        ];
-        return criticalPatterns.some((pattern) => pattern.test(message));
-    }
-    info(message) {
-        if (this.silent)
-            return;
-        console.log(chalk.blue("ℹ"), message);
-    }
-    success(message) {
-        if (this.silent)
-            return;
-        console.log(chalk.green("✓"), message);
-    }
-    error(message) {
-        // Allow critical errors through even in silent mode
-        if (this.silent && !this.isCriticalError(message))
-            return;
-        console.error(chalk.red("✗"), message);
-    }
-    warn(message) {
-        if (this.silent)
-            return;
-        console.warn(chalk.yellow("⚠"), message);
-    }
-    debug(message, data) {
-        this.writeToFile("DEBUG", message, data);
-        if (this.silent)
-            return;
-        if (this.verbose) {
-            console.log(chalk.gray("→"), message);
-            if (data) {
-                console.log(chalk.gray(JSON.stringify(data, null, 2)));
-            }
-        }
-    }
-    section(title) {
-        if (this.silent)
-            return;
-        console.log("\n" + chalk.bold.red(`━━━ ${title} ━━━`));
-    }
-    summary(title) {
-        if (this.silent)
-            return;
-        console.log("\n" + chalk.bold.cyan(`╔═══ ${title} ═══╗`));
-    }
-    raw(message) {
-        if (this.silent)
-            return;
-        console.log(message);
-    }
-    stream(chunk) {
-        if (this.silent)
-            return;
-        process.stdout.write(chalk.dim(chunk));
-    }
-    toolRead(filePath) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.blue("📖"), chalk.dim("Reading:"), chalk.white(filePath));
-    }
-    toolWrite(filePath) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.green("✏️"), chalk.dim("Writing:"), chalk.white(filePath));
-    }
-    toolEdit(filePath) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.yellow("✏️"), chalk.dim("Editing:"), chalk.white(filePath));
-    }
-    toolBash(command) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.cyan("🔨"), chalk.dim("Running:"), chalk.white(command));
-    }
-    toolSearch(type, pattern) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.cyan("🔍"), chalk.dim(`Searching ${type}:`), chalk.white(pattern));
-    }
-    toolAgent(agentType) {
-        if (this.silent)
-            return;
-        console.log("");
-        console.log(chalk.cyan("🤖"), chalk.dim("Launching agent:"), chalk.white(agentType));
-    }
-    todoUpdate(todos) {
-        if (this.silent)
-            return;
-        const completed = todos.filter((t) => t.status === "completed");
-        const inProgress = todos.filter((t) => t.status === "in_progress");
-        const pending = todos.filter((t) => t.status === "pending");
-        const total = todos.length;
-        const completedCount = completed.length;
-        const progress = total > 0 ? Math.round((completedCount / total) * 100) : 0;
-        // Progress bar
-        const barLength = 20;
-        const filledLength = Math.round((barLength * completedCount) / total);
-        const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
-        console.log("");
-        console.log(chalk.blue("📝"), chalk.dim("Todo Progress:"), chalk.cyan(bar), chalk.white(`${progress}%`), chalk.gray(`(${completedCount}/${total})`));
-        // Show individual todos with status indicators
-        if (inProgress.length > 0) {
-            for (const todo of inProgress) {
-                console.log("  ", chalk.yellow("→"), chalk.white(todo.content), chalk.gray("[in progress]"));
-            }
-        }
-        if (completed.length > 0 && completed.length <= 3) {
-            for (const todo of completed) {
-                console.log("  ", chalk.green("✓"), chalk.gray(todo.content), chalk.dim("[completed]"));
-            }
-        }
-        if (pending.length > 0 && pending.length <= 3) {
-            for (const todo of pending) {
-                console.log("  ", chalk.dim("⏳"), chalk.white(todo.content), chalk.gray("[pending]"));
-            }
-        }
-    }
-    divider() {
-        if (this.silent)
-            return;
-        console.log(chalk.gray("─".repeat(60)));
-    }
-    box(title) {
-        if (this.silent)
-            return;
-        const width = 60;
-        const padding = Math.max(0, width - title.length - 2);
-        const leftPad = Math.floor(padding / 2);
-        const rightPad = Math.ceil(padding / 2);
-        console.log(chalk.cyan("╔" + "═".repeat(width) + "╗"));
-        console.log(chalk.cyan("║") +
-            " ".repeat(leftPad) +
-            chalk.bold.white(title) +
-            " ".repeat(rightPad) +
-            chalk.cyan("║"));
-        console.log(chalk.cyan("╚" + "═".repeat(width) + "╝"));
-    }
-}
-export const logger = new Logger();

package/dist/utils/node-version.js

@@ -1,89 +0,0 @@
-import { execSync } from "node:child_process";
-import { logger } from "./logger";
-const MINIMUM_NODE_VERSION = 18;
-/**
- * Parse a version string like "v18.17.0" or "18.17.0" into components
- */
-function parseVersion(versionString) {
-    const cleaned = versionString.trim().replace(/^v/, "");
-    const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
-    if (!match) {
-        return null;
-    }
-    return {
-        major: Number.parseInt(match[1], 10),
-        minor: Number.parseInt(match[2], 10),
-        patch: Number.parseInt(match[3], 10),
-        raw: versionString.trim(),
-    };
-}
-/**
- * Get the installed Node.js version
- */
-function getNodeVersion() {
-    try {
-        // Try to get version from child process (works when Node.js is available)
-        const versionOutput = execSync("node --version", {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        return parseVersion(versionOutput);
-    }
-    catch (error) {
-        // Node.js not found or not accessible
-        return null;
-    }
-}
-/**
- * Check if Node.js is installed and meets minimum version requirements
- * @throws Error with helpful message if requirements not met
- */
-export function checkNodeVersion() {
-    const nodeVersion = getNodeVersion();
-    if (!nodeVersion) {
-        logger.error("Node.js is not installed or not accessible");
-        logger.error("");
-        logger.error("Supatest AI requires Node.js 18 or higher to run.");
-        logger.error("");
-        logger.error("Please install Node.js:");
-        logger.error("  • macOS:   brew install node");
-        logger.error("  • Linux:   Use your package manager or nvm");
-        logger.error("  • Windows: Download from https://nodejs.org/");
-        logger.error("");
-        logger.error("Or use nvm (Node Version Manager):");
-        logger.error("  nvm install 18");
-        logger.error("  nvm use 18");
-        logger.error("");
-        logger.error("Verify installation: node --version");
-        process.exit(1);
-    }
-    if (nodeVersion.major < MINIMUM_NODE_VERSION) {
-        logger.error(`Node.js ${nodeVersion.raw} is installed, but version ${MINIMUM_NODE_VERSION} or higher is required`);
-        logger.error("");
-        logger.error(`Current version: ${nodeVersion.raw}`);
-        logger.error(`Required version: ${MINIMUM_NODE_VERSION}.0.0 or higher`);
-        logger.error("");
-        logger.error("Please upgrade Node.js:");
-        logger.error("  • macOS:   brew upgrade node");
-        logger.error("  • Linux:   Use your package manager or nvm");
-        logger.error("  • Windows: Download from https://nodejs.org/");
-        logger.error("");
-        logger.error("Or use nvm to install a newer version:");
-        logger.error(`  nvm install ${MINIMUM_NODE_VERSION}`);
-        logger.error(`  nvm use ${MINIMUM_NODE_VERSION}`);
-        logger.error("");
-        logger.error("Verify upgrade: node --version");
-        process.exit(1);
-    }
-    // Success - version is adequate
-}
-/**
- * Get Node.js version info for display purposes
- */
-export function getNodeVersionInfo() {
-    const version = getNodeVersion();
-    if (!version) {
-        return "Not installed";
-    }
-    return version.raw;
-}

package/dist/utils/plan-file.js

@@ -1,75 +0,0 @@
-/**
- * Plan file utilities
- * Handles creation and management of plan files for plan mode
- */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-const PLAN_DIR = ".supatest/plans";
-/**
- * Generate a unique plan file name with timestamp
- */
-function generatePlanFileName() {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return `plan-${timestamp}.md`;
-}
-/**
- * Create a new plan file in the .supatest/plans directory
- * @param cwd - The current working directory (project root)
- * @returns The path to the created plan file
- */
-export async function createPlanFile(cwd) {
-    const planDir = join(cwd, PLAN_DIR);
-    // Ensure the plan directory exists
-    await mkdir(planDir, { recursive: true });
-    const planFileName = generatePlanFileName();
-    const planPath = join(planDir, planFileName);
-    // Create the initial plan file with a placeholder
-    const initialContent = `# Plan
-
-_Planning in progress..._
-
----
-
-## Summary
-
-_To be filled by the agent_
-
-## Tasks
-
-_To be filled by the agent_
-
-## Files to Modify
-
-_To be filled by the agent_
-
----
-
-_Generated by Supatest AI_
-`;
-    await writeFile(planPath, initialContent, "utf-8");
-    return planPath;
-}
-/**
- * Update the contents of an existing plan file
- * @param planPath - The path to the plan file
- * @param content - The new content to write
- */
-export async function updatePlanFile(planPath, content) {
-    await writeFile(planPath, content, "utf-8");
-}
-/**
- * Read the contents of a plan file
- * @param planPath - The path to the plan file
- * @returns The contents of the plan file
- */
-export async function readPlanFile(planPath) {
-    return await readFile(planPath, "utf-8");
-}
-/**
- * Get the plan directory path for a given project
- * @param cwd - The current working directory (project root)
- * @returns The path to the plan directory
- */
-export function getPlanDirectory(cwd) {
-    return join(cwd, PLAN_DIR);
-}

package/dist/utils/project-instructions.js

@@ -1,23 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-/**
- * Load project-specific instructions from SUPATEST.md
- * Checks multiple locations in order of precedence
- */
-export function loadProjectInstructions(cwd) {
-    const paths = [
-        join(cwd, "SUPATEST.md"),
-        join(cwd, ".supatest", "SUPATEST.md"),
-    ];
-    for (const path of paths) {
-        if (existsSync(path)) {
-            try {
-                return readFileSync(path, "utf-8");
-            }
-            catch {
-                // Skip if can't read
-            }
-        }
-    }
-    return undefined;
-}