@supatest/cli 0.0.3 → 0.0.4

package/dist/core/agent.js

@@ -1,270 +0,0 @@
-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/modes/headless.js

@@ -1,117 +0,0 @@
-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,
-        };
-    }
-}