@supatest/cli 0.0.2 → 0.0.3

package/dist/core/agent.js

@@ -0,0 +1,270 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { config as envConfig } from "../config";
+import { loadProjectInstructions } from "../utils/project-instructions";
+export class CoreAgent {
+    presenter;
+    abortController = null;
+    constructor(presenter) {
+        this.presenter = presenter;
+    }
+    /**
+     * Abort the current query execution.
+     * This will cancel any running operations including LLM calls and tool executions.
+     */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    async run(config) {
+        // Create a fresh AbortController for this run
+        this.abortController = new AbortController();
+        await this.presenter.onStart(config);
+        // Resolve path to Claude Code executable
+        const claudeCodePath = await this.resolveClaudeCodePath();
+        // Build the prompt
+        let prompt = config.task;
+        if (config.logs) {
+            prompt = `${config.task}\n\nHere are the logs to analyze:\n\`\`\`\n${config.logs}\n\`\`\``;
+        }
+        // Apply permission mode based on agent mode
+        // Plan mode uses 'plan' permission which restricts to read-only tools
+        // Build mode uses 'bypassPermissions' for full tool access
+        const isPlanMode = config.mode === 'plan';
+        const cwd = config.cwd || process.cwd();
+        // Only load system prompt for new sessions - resumed sessions already have it
+        // This avoids duplicating system prompt tokens on every continuation
+        const isResumingSession = !!config.providerSessionId;
+        let systemPromptAppend;
+        if (!isResumingSession) {
+            // Load project instructions from SUPATEST.md
+            const projectInstructions = loadProjectInstructions(cwd);
+            // Combine system prompts: base prompt + project instructions
+            systemPromptAppend = [
+                config.systemPromptAppend,
+                projectInstructions && `\n\n# Project Instructions (from SUPATEST.md)\n\n${projectInstructions}`,
+            ].filter(Boolean).join("\n") || undefined;
+        }
+        const queryOptions = {
+            // AbortController for cancellation support
+            abortController: this.abortController,
+            maxTurns: config.maxIterations,
+            cwd,
+            model: envConfig.anthropicModelName,
+            permissionMode: isPlanMode ? "plan" : "bypassPermissions",
+            allowDangerouslySkipPermissions: !isPlanMode,
+            pathToClaudeCodeExecutable: claudeCodePath,
+            includePartialMessages: true,
+            executable: "node",
+            // MCP servers for enhanced capabilities
+            mcpServers: {
+                playwright: {
+                    command: "npx",
+                    args: ["-y", "@playwright/mcp@latest"],
+                },
+            },
+            // Resume from previous session if providerSessionId is provided
+            // This allows the agent to continue conversations with full context
+            // Note: Sessions expire after ~30 days due to Anthropic's data retention policy
+            ...(config.providerSessionId && {
+                resume: config.providerSessionId,
+            }),
+            // Only append system prompt for new sessions - resumed sessions already have context
+            ...(systemPromptAppend && {
+                systemPrompt: {
+                    type: "preset",
+                    preset: "claude_code",
+                    append: systemPromptAppend,
+                },
+            }),
+            env: {
+                ...process.env,
+                ANTHROPIC_API_KEY: config.supatestApiKey,
+                ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || "",
+                ANTHROPIC_AUTH_TOKEN: "",
+                CLAUDE_CODE_AUTH_TOKEN: "",
+            },
+            stderr: (msg) => {
+                this.presenter.onLog(`[Claude Code stderr] ${msg}`);
+            },
+        };
+        let resultText = "";
+        let hasError = false;
+        const errors = [];
+        let iterations = 0;
+        const filesModified = new Set();
+        let wasInterrupted = false;
+        // Capture the SDK's session_id for future resume capability
+        let providerSessionId;
+        // Track cumulative token usage
+        let totalInputTokens = config.initialTokens || 0;
+        let totalOutputTokens = 0;
+        // Helper to check if an error indicates an expired/invalid session
+        const isSessionExpiredError = (errorMsg) => {
+            const expiredPatterns = [
+                "no conversation found",
+                "session not found",
+                "session expired",
+                "invalid session",
+            ];
+            const lowerError = errorMsg.toLowerCase();
+            return expiredPatterns.some((pattern) => lowerError.includes(pattern));
+        };
+        // Helper to run the query and process messages
+        const runQuery = async (options) => {
+            for await (const msg of query({ prompt, options })) {
+                // Capture session_id from any message that has it
+                // All SDK messages include session_id which we need for resuming
+                if ("session_id" in msg && msg.session_id) {
+                    providerSessionId = msg.session_id;
+                }
+                if (msg.type === "assistant") {
+                    iterations++;
+                    const content = msg.message.content;
+                    // Extract and accumulate token usage from this turn
+                    const usage = msg.message.usage;
+                    if (usage) {
+                        totalInputTokens += usage.input_tokens || 0;
+                        totalOutputTokens += usage.output_tokens || 0;
+                        // Notify presenter of updated token count
+                        await this.presenter.onUsageUpdate?.(totalInputTokens + totalOutputTokens);
+                    }
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "text") {
+                                resultText += block.text + "\n";
+                                await this.presenter.onAssistantText(block.text);
+                            }
+                            else if (block.type === "thinking") {
+                                await this.presenter.onThinking(block.thinking);
+                            }
+                            else if (block.type === "tool_use") {
+                                const toolName = block.name;
+                                const input = block.input;
+                                // Track file modifications
+                                if ((toolName === "Write" || toolName === "Edit") &&
+                                    input?.file_path) {
+                                    filesModified.add(input.file_path);
+                                }
+                                await this.presenter.onToolUse(toolName, input, block.id);
+                            }
+                        }
+                    }
+                    // Notify presenter that the turn is complete
+                    await this.presenter.onTurnComplete(content);
+                }
+                else if (msg.type === "result") {
+                    iterations = msg.num_turns;
+                    if (msg.subtype === "success") {
+                        resultText = msg.result || resultText;
+                    }
+                    else {
+                        hasError = true;
+                        if ("errors" in msg && Array.isArray(msg.errors)) {
+                            errors.push(...msg.errors);
+                            for (const error of msg.errors) {
+                                await this.presenter.onError(error);
+                            }
+                        }
+                    }
+                }
+                else if (msg.type === "user") {
+                    // User message contains tool results - end tool timing
+                    const userContent = msg.message?.content;
+                    if (Array.isArray(userContent)) {
+                        for (const block of userContent) {
+                            if (block.type === "tool_result" && block.tool_use_id) {
+                                // Notify presenter of tool result
+                                if (this.presenter.onToolResult) {
+                                    const resultContent = Array.isArray(block.content)
+                                        ? block.content.map((c) => c.text || "").join("\n")
+                                        : typeof block.content === "string"
+                                            ? block.content
+                                            : "";
+                                    await this.presenter.onToolResult(block.tool_use_id, resultContent);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        try {
+            await runQuery(queryOptions);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this was an abort (user interrupt)
+            // The SDK may throw AbortError or a message containing "aborted"
+            const isAbortError = (error instanceof Error && error.name === "AbortError") ||
+                errorMessage.toLowerCase().includes("aborted");
+            if (isAbortError) {
+                wasInterrupted = true;
+            }
+            else if (config.providerSessionId && isSessionExpiredError(errorMessage)) {
+                // If the error indicates an expired session and we were trying to resume,
+                // show a user-friendly error message
+                const expiredMessage = "Can't continue conversation older than 30 days. Please start a new session.";
+                await this.presenter.onError(expiredMessage);
+                hasError = true;
+                errors.push(expiredMessage);
+            }
+            else {
+                await this.presenter.onError(errorMessage);
+                hasError = true;
+                errors.push(errorMessage);
+            }
+        }
+        const result = {
+            success: !hasError && errors.length === 0 && !wasInterrupted,
+            summary: wasInterrupted ? "Interrupted by user" : resultText || "Task completed",
+            filesModified: Array.from(filesModified),
+            iterations,
+            error: wasInterrupted
+                ? "Interrupted by user"
+                : errors.length > 0
+                    ? errors.join("; ")
+                    : undefined,
+            // Include the provider session ID for resume capability
+            providerSessionId,
+        };
+        await this.presenter.onComplete(result);
+        return result;
+    }
+    async resolveClaudeCodePath() {
+        // Allow override via environment variable
+        if (envConfig.claudeCodeExecutablePath) {
+            this.presenter.onLog(`Using CLAUDE_CODE_EXECUTABLE_PATH: ${envConfig.claudeCodeExecutablePath}`);
+            return envConfig.claudeCodeExecutablePath;
+        }
+        // Determine binary directory
+        const isCompiledBinary = process.execPath && !process.execPath.includes("node");
+        let claudeCodePath;
+        if (isCompiledBinary) {
+            claudeCodePath = join(dirname(process.execPath), "claude-code-cli.js");
+            this.presenter.onLog(`Production mode: ${claudeCodePath}`);
+        }
+        else {
+            const require = createRequire(import.meta.url);
+            const sdkPath = require.resolve("@anthropic-ai/claude-agent-sdk/sdk.mjs");
+            claudeCodePath = join(dirname(sdkPath), "cli.js");
+            this.presenter.onLog(`Development mode: ${claudeCodePath}`);
+        }
+        // Verify the file exists
+        const fs = await import("node:fs/promises");
+        try {
+            await fs.access(claudeCodePath);
+            this.presenter.onLog(`✓ Claude Code CLI found: ${claudeCodePath}`);
+        }
+        catch {
+            const error = `Claude Code executable not found at: ${claudeCodePath}\n` +
+                "For compiled binaries, ensure claude-code-cli.js is in the same directory as the binary.\n" +
+                "Set CLAUDE_CODE_EXECUTABLE_PATH environment variable to override.";
+            await this.presenter.onError(error);
+            throw new Error(error);
+        }
+        return claudeCodePath;
+    }
+}

package/dist/index.js

@@ -1,29 +1,49 @@
 #!/usr/bin/env node
+import "./config";
 import { Command } from "commander";
-import { runAgent } from "./agent-runner.js";
-import { getBanner } from "./utils/banner.js";
-import { logger } from "./utils/logger.js";
-import { checkNodeVersion } from "./utils/node-version.js";
-import { readStdin } from "./utils/stdin.js";
+import { setupCommand } from "./commands/setup";
+import { config as envConfig } from "./config";
+import { runAgent } from "./modes/headless";
+import { getBanner } from "./utils/banner";
+import { logger } from "./utils/logger";
+import { checkNodeVersion } from "./utils/node-version";
+import { readStdin } from "./utils/stdin";
+import { loadTokenAsync } from "./utils/token-storage";
 const program = new Command();
+// Main run command (default)
 program
-    .name("supatest-ai")
+    .name("supatest")
     .description("AI-powered task automation CLI for CI/CD - fix tests, lint issues, and more")
     .version("1.0.0")
     .argument("[task]", "Task description or prompt for the AI agent")
     .option("-l, --logs <file>", "Path to log file to analyze")
     .option("--stdin", "Read logs from stdin")
+    .option("-C, --cwd <path>", "Working directory for the agent", process.cwd())
     .option("-m, --max-iterations <number>", "Maximum number of iterations", "100")
-    .option("--api-key <key>", "Anthropic API key (or use ANTHROPIC_API_KEY env)")
+    .option("--supatest-api-key <key>", "Supatest API key (or use SUPATEST_API_KEY env)")
+    .option("--supatest-api-url <url>", "Supatest API URL (or use SUPATEST_API_URL env, defaults to https://api.supatest.ai)")
+    .option("--headless", "Run in headless mode (for CI/CD, minimal output)")
     .option("--verbose", "Enable verbose logging")
     .action(async (task, options) => {
     try {
-        // Set verbose mode early
+        // Check Node.js version early
+        checkNodeVersion();
+        // Determine mode: headless or interactive
+        // Headless mode when:
+        // - --headless flag is set
+        // - stdin is explicitly false (piped input, not undefined)
+        const isHeadlessMode = options.headless ||
+            process.stdin.isTTY === false;
+        // Set verbose and silent modes early
         if (options.verbose) {
             logger.setVerbose(true);
         }
-        // Check Node.js version (after setting verbose mode)
-        checkNodeVersion();
+        // Enable file logging in development
+        const isDev = process.env.NODE_ENV === "development";
+        logger.enableFileLogging(isDev);
+        // In headless mode, suppress banner and interactive output
+        // We don't set silent=true here because we still want to see the execution log in CI
+        // logger.setSilent(true);
         // Validate task or stdin
         let prompt = task;
         let logs;
@@ -47,36 +67,103 @@ program
                 process.exit(1);
             }
         }
-        if (!prompt) {
-            logger.error("Task description is required");
+        // In interactive mode, task is optional (will prompt for input)
+        // In headless mode, task is required
+        if (!prompt && isHeadlessMode) {
+            logger.error("Task description is required in headless mode");
             program.help();
             process.exit(1);
         }
-        // Get API key from options or environment
-        const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            logger.error("Anthropic API key required. Set ANTHROPIC_API_KEY environment variable or use --api-key option");
-            process.exit(1);
+        // Authentication priority:
+        // - In CI mode: Only API key (flag or env var)
+        // - In non-CI mode: Prefer user token, fallback to API key
+        let supatestApiKey;
+        const supatestApiUrl = options.supatestApiUrl || envConfig.supatestApiUrl;
+        if (isHeadlessMode) {
+            // CI/Headless mode: Only use API keys (team sessions)
+            supatestApiKey = options.supatestApiKey || envConfig.supatestApiKey;
+            if (!supatestApiKey) {
+                logger.error("API key required in CI/headless mode. Please either:");
+                logger.error("  1. Set SUPATEST_API_KEY environment variable");
+                logger.error("  2. Use --supatest-api-key option");
+                process.exit(1);
+            }
+        }
+        else {
+            // Interactive/Local mode: Prefer user token (personal sessions)
+            // If no auth available, the interactive UI will prompt for login
+            const cliToken = await loadTokenAsync();
+            if (cliToken) {
+                supatestApiKey = cliToken;
+            }
+            else {
+                // Fallback to API key if no user token
+                supatestApiKey = options.supatestApiKey || envConfig.supatestApiKey;
+            }
+            // Note: supatestApiKey may be undefined here - interactive UI handles login prompts
+        }
+        // Branch to appropriate mode
+        if (isHeadlessMode) {
+            // Headless/CI mode: simple output for automation
+            // At this point, prompt is guaranteed to be defined due to earlier check
+            if (!prompt) {
+                throw new Error("Task is required in headless mode");
+            }
+            logger.raw(getBanner());
+            const result = await runAgent({
+                task: prompt,
+                logs,
+                supatestApiKey,
+                supatestApiUrl,
+                maxIterations: Number.parseInt(options.maxIterations || "100", 10),
+                verbose: options.verbose || false,
+                cwd: options.cwd,
+                systemPromptAppend: envConfig.headlessSystemPrompt,
+            });
+            process.exit(result.success ? 0 : 1);
+        }
+        else {
+            // Interactive mode: full UI with Ink + React
+            const { runInteractive } = await import("./modes/interactive.js");
+            await runInteractive({
+                task: prompt || "", // Empty string if no task provided (will use input prompt)
+                logs,
+                supatestApiKey,
+                supatestApiUrl,
+                maxIterations: Number.parseInt(options.maxIterations || "100", 10),
+                verbose: options.verbose || false,
+                cwd: options.cwd,
+                systemPromptAppend: envConfig.interactiveSystemPrompt,
+            });
+            // Interactive mode handles its own exit
         }
-        // Display banner
-        logger.raw(getBanner());
-        // Run the agent
-        const result = await runAgent({
-            task: prompt,
-            logs,
-            apiKey,
-            maxIterations: Number.parseInt(options.maxIterations || "100", 10),
-            verbose: options.verbose || false,
-        });
-        // Exit with appropriate code
-        process.exit(result.success ? 0 : 1);
     }
     catch (error) {
         logger.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
-        if (options.verbose && error instanceof Error) {
+        if (error instanceof Error) {
             console.error(error.stack);
         }
         process.exit(1);
     }
 });
-program.parse();
+// Setup command - check prerequisites and install Playwright MCP
+program
+    .command("setup")
+    .description("Check prerequisites and set up required tools (Node.js, Playwright MCP)")
+    .action(async () => {
+    try {
+        const result = await setupCommand();
+        process.exit(result.errors.length === 0 ? 0 : 1);
+    }
+    catch (error) {
+        logger.error(`Setup failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});
+// Filter out the standalone '--' separator that pnpm/tsx adds
+// This prevents Commander from treating everything after '--' as positional args
+const filteredArgv = process.argv.filter((arg, index) => {
+    // Remove '--' only if it's a standalone argument (not part of a flag like '--verbose')
+    return !(arg === '--' && index > 1);
+});
+program.parse(filteredArgv);

package/dist/modes/headless.js

@@ -0,0 +1,117 @@
+import chalk from "chalk";
+import { config as envConfig } from "../config";
+import { CoreAgent } from "../core/agent";
+import { CompositePresenter } from "../presenters/composite";
+import { ConsolePresenter } from "../presenters/console";
+import { WebPresenter } from "../presenters/web";
+import { ApiClient } from "../services/api-client";
+import { logger } from "../utils/logger";
+const CLI_VERSION = "0.0.1";
+export async function runAgent(config) {
+    // Configure logger
+    logger.setVerbose(config.verbose);
+    // --- Metadata Display (CLI only) ---
+    logger.raw("");
+    // Get git branch if available
+    let gitBranch = "";
+    try {
+        const { execSync } = await import("node:child_process");
+        gitBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "ignore"]
+        }).trim();
+    }
+    catch {
+        // Not in a git repo or git not available
+    }
+    const metadataParts = [
+        chalk.dim("Supatest AI ") + chalk.cyan(`v${CLI_VERSION}`),
+        chalk.dim("Model: ") + chalk.cyan(envConfig.anthropicModelName),
+    ];
+    if (gitBranch) {
+        metadataParts.push(chalk.dim("Branch: ") + chalk.cyan(gitBranch));
+    }
+    logger.raw(metadataParts.join(chalk.dim(" • ")));
+    logger.divider();
+    // --- Session & API Setup ---
+    const apiUrl = config.supatestApiUrl || "https://api.supatest.ai";
+    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
+    let sessionId;
+    let webUrl;
+    try {
+        // Truncate title to 50 characters (backend will auto-generate a better title later)
+        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;
+        logger.raw("");
+        logger.divider();
+        logger.raw(chalk.white.bold("View session live: ") +
+            chalk.cyan.underline(webUrl));
+        logger.divider();
+        logger.raw("");
+    }
+    catch (error) {
+        logger.warn(`Failed to create session on backend: ${error.message}`);
+        logger.warn("Continuing without web streaming...");
+    }
+    // --- Environment Setup ---
+    // Build base URL with session ID embedded for the proxy
+    let baseUrl = `${apiUrl}/public`;
+    if (sessionId) {
+        baseUrl = `${apiUrl}/v1/sessions/${sessionId}/anthropic`;
+    }
+    // Set environment variables for the SDK to pick up (via CoreAgent)
+    process.env.ANTHROPIC_BASE_URL = baseUrl;
+    process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
+    // --- Agent Execution ---
+    const presenters = [];
+    // 1. Console Presenter (stdout)
+    presenters.push(new ConsolePresenter({ verbose: config.verbose }));
+    // 2. Web Presenter (streaming)
+    if (sessionId) {
+        presenters.push(new WebPresenter(apiClient, sessionId));
+    }
+    const compositePresenter = new CompositePresenter(presenters);
+    const agent = new CoreAgent(compositePresenter);
+    try {
+        const result = await agent.run(config);
+        // Store the provider session ID for future resume capability
+        // This allows follow-up messages to continue the conversation with full context
+        if (sessionId && result.providerSessionId) {
+            try {
+                await apiClient.updateSession(sessionId, {
+                    providerSessionId: result.providerSessionId,
+                });
+                logger.debug(`Stored provider session ID for resume capability`);
+            }
+            catch (updateError) {
+                // Non-critical - log but don't fail
+                logger.warn(`Failed to store provider session ID: ${updateError.message}`);
+            }
+        }
+        // Display web URL again at completion
+        if (webUrl) {
+            logger.raw("");
+            logger.divider();
+            logger.raw(chalk.white.bold("View session: ") +
+                chalk.cyan.underline(webUrl));
+            logger.divider();
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Error is already logged by presenter.onError
+        return {
+            success: false,
+            summary: `Failed: ${errorMessage}`,
+            filesModified: [],
+            iterations: 0,
+            error: errorMessage,
+        };
+    }
+}