@supatest/cli 0.0.4 → 0.0.5

package/dist/core/agent.js

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