@timetotest/cli 0.2.3 → 0.3.0

package/dist/src/commands/chat-ink.js

@@ -7,19 +7,11 @@ import chalk from "chalk";
 import React from "react";
 import { render } from "ink";
 import { AgentOrchestrator } from "../lib/agent-orchestrator.js";
-import { resolveApiUrl, getAuthToken } from "../lib/config.js";
-import { getToolDescription } from "../lib/tool-descriptions.js";
+import { resolveApiUrl, getAuthToken, configManager } from "../lib/config.js";
 import { ChatApp } from "./chat/ChatApp.js";
 import { performInteractiveLogin } from "./login.js";
 import { resolveTestingMode } from "../lib/testing-mode.js";
-export const chatInk = new Command()
-    .name("chat")
-    .description("Start an interactive chat session with the test agent (INK UI)")
-    .option("--mode <mode>", "Testing mode: ui or api", "ui")
-    .option("--base-url <url>", "Base URL for UI testing", process.env.TTT_BASE_URL)
-    .option("--api-base-url <url>", "Base URL for API testing", process.env.TTT_API_BASE_URL)
-    .option("--session <id>", "Resume existing session by ID")
-    .action(async (options) => {
+export async function runChatInk(options) {
     try {
         const apiUrl = resolveApiUrl();
         let token = getAuthToken();
@@ -71,19 +63,27 @@ export const chatInk = new Command()
                 }
             }
             else {
-                console.log(chalk.gray(`ℹ️  Unable to fetch user info: ${error?.message || error}`));
+                console.error(chalk.gray(`ℹ️  Unable to fetch user info: ${error?.message || error}`));
             }
         }
         // Determine mode (local is default)
         const mode = "local";
-        console.log(chalk.green("✓ Running in LOCAL mode"));
+        // Load saved mode preference, use --mode flag if provided, otherwise fall back to saved or default
         let testingMode;
         try {
-            testingMode = resolveTestingMode(options.mode ?? "ui", {
-                defaultMode: "ui",
-                strict: true,
-                contextLabel: "--mode",
-            });
+            if (options.mode) {
+                // User explicitly provided --mode flag
+                testingMode = resolveTestingMode(options.mode, {
+                    defaultMode: "ui",
+                    strict: true,
+                    contextLabel: "--mode",
+                });
+            }
+            else {
+                // Try to load saved mode preference
+                const savedMode = await configManager.getLastMode();
+                testingMode = savedMode ?? "ui";
+            }
         }
         catch (error) {
             console.error(chalk.red(error?.message || String(error)));
@@ -102,6 +102,17 @@ export const chatInk = new Command()
         function getAppInterface() {
             return globalThis.__chatAppInterface;
         }
+        // Set up permission prompt handler - delegates to ChatApp UI
+        const permissionPromptFn = async (request) => {
+            const appInterface = getAppInterface();
+            if (!appInterface?.promptPermission) {
+                // Fallback: deny if UI not available
+                return "deny";
+            }
+            return appInterface.promptPermission(request);
+        };
+        // Wire up permission handler to orchestrator's tool executor
+        orchestrator.setPermissionPromptFn(permissionPromptFn);
         function handleUserCancel() {
             const appInterface = getAppInterface();
             const wasCancelled = userCancelled;
@@ -118,46 +129,61 @@ export const chatInk = new Command()
             orchestrator.cancel();
         }
         // Set up event listeners for tool execution with frontend-style display
-        orchestrator.on("assistant_reasoning", (data) => {
+        const onAssistantReasoning = (data) => {
             if (userCancelled) {
                 return;
             }
             const appInterface = getAppInterface();
             const reasoning = data.data?.reasoning || data.message;
             if (reasoning && reasoning.trim()) {
-                // Add reasoning as a system message to show in history
+                // Add reasoning as a system message with special formatting
                 appInterface?.addMessage({
                     id: `reasoning-${Date.now()}`,
                     type: "system",
-                    content: `${reasoning}`,
+                    content: reasoning,
+                    metadata: { isReasoning: true },
                 });
             }
-        });
-        orchestrator.on("tool_start", (data) => {
+        };
+        const onToolStart = (data) => {
             if (userCancelled) {
                 return;
             }
             const appInterface = getAppInterface();
             const toolName = data.data?.tool || data.tool;
-            const description = getToolDescription(toolName);
-            // Add tool event as a system message to show in history
+            const toolArgs = data.data?.arguments || {};
+            // Add tool call as a system message with tool metadata
             appInterface?.addMessage({
                 id: `tool-${Date.now()}`,
                 type: "system",
-                content: `🔧 ${toolName.replace(/_/g, " ")} - ${description}`,
+                content: "", // Content will be rendered by ToolCallDisplay
+                metadata: {
+                    isTool: true,
+                    toolName,
+                    toolArgs,
+                    isLoading: true,
+                },
             });
             appInterface?.setStatus({
                 text: "Agent thinking...",
                 type: "loading",
             });
-        });
-        orchestrator.on("tool_result", () => {
+        };
+        const onToolResult = (data) => {
             if (userCancelled) {
                 return;
             }
-            // Tool completion is intentionally silent now.
-        });
-        orchestrator.on("agent_cancelled", () => {
+            const appInterface = getAppInterface();
+            const toolName = data.data?.tool || data.tool;
+            const result = data.data?.result;
+            // Update the last tool message with the result
+            appInterface?.updateLastToolMessage?.({
+                toolName,
+                result,
+                isLoading: false,
+            });
+        };
+        const onAgentCancelled = () => {
             if (userCancelled) {
                 return;
             }
@@ -168,7 +194,18 @@ export const chatInk = new Command()
                 type: "system",
                 content: "🛑 Cancelled — the assistant has stopped. Type whenever you're ready.",
             });
-        });
+        };
+        orchestrator.on("assistant_reasoning", onAssistantReasoning);
+        orchestrator.on("tool_start", onToolStart);
+        orchestrator.on("tool_result", onToolResult);
+        orchestrator.on("agent_cancelled", onAgentCancelled);
+        const cleanupOrchestratorListeners = () => {
+            // EventEmitter supports `off` in modern Node, but be tolerant.
+            (orchestrator.off ?? orchestrator.removeListener).call(orchestrator, "assistant_reasoning", onAssistantReasoning);
+            (orchestrator.off ?? orchestrator.removeListener).call(orchestrator, "tool_start", onToolStart);
+            (orchestrator.off ?? orchestrator.removeListener).call(orchestrator, "tool_result", onToolResult);
+            (orchestrator.off ?? orchestrator.removeListener).call(orchestrator, "agent_cancelled", onAgentCancelled);
+        };
         // Initialize context
         const chatContext = {
             sessionId: orchestrator.getSessionId(),
@@ -188,8 +225,117 @@ export const chatInk = new Command()
             chatContext.toolCount = history.filter((msg) => msg.role === "tool").length;
         };
         updateContextFromOrchestrator();
-        // Define slash commands
+        // Define slash commands (alphabetically sorted)
         const slashCommands = [
+            {
+                name: "cancel",
+                description: "Alias for /stop",
+                handler: async () => {
+                    handleUserCancel();
+                    return "continue";
+                },
+            },
+            {
+                name: "clear",
+                description: "Clear the transcript visually",
+                handler: async () => "continue",
+            },
+            {
+                name: "bugs",
+                description: "List all bugs identified in this session",
+                handler: async (args, orchestrator) => {
+                    const history = orchestrator.getConversationHistory();
+                    const findings = history
+                        .filter((msg) => msg.role === "tool" && msg.toolCall?.name === "generate_document")
+                        .map((msg) => {
+                        try {
+                            const res = JSON.parse(msg.content);
+                            return res.findings || [];
+                        }
+                        catch {
+                            return [];
+                        }
+                    })
+                        .flat();
+                    const appInterface = getAppInterface();
+                    if (findings.length === 0) {
+                        appInterface?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: "No bugs have been formally reported yet. Use /report to generate a report.",
+                        });
+                    }
+                    else {
+                        const list = findings
+                            .map((f, i) => `${i + 1}. [${f.severity?.toUpperCase()}] ${f.title}`)
+                            .join("\n");
+                        appInterface?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `🐞 Identified Bugs:\n${list}`,
+                        });
+                    }
+                    return "continue";
+                },
+            },
+            {
+                name: "compact",
+                description: "Compact conversation context to manage token limits",
+                handler: async () => {
+                    const stats = orchestrator.getContextStats();
+                    const appInterface = getAppInterface();
+                    if (!stats.needsCompaction) {
+                        appInterface?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `Context: ${stats.totalMessages} messages, ${stats.tokens.toLocaleString()} tokens (${stats.utilizationPercent.toFixed(1)}% of limit), ${stats.conversationTurns} turns. No compaction needed.`,
+                        });
+                        return "continue";
+                    }
+                    const result = await orchestrator.compactContext();
+                    appInterface?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: `✅ Context compacted: ${result.stats.removedCount} messages removed\n` +
+                            `Before: ${result.stats.tokensBeforeCompaction.toLocaleString()} tokens\n` +
+                            `After: ${result.stats.tokensAfterCompaction.toLocaleString()} tokens\n` +
+                            `Strategy: ${result.stats.strategy}` +
+                            (result.stats.summaryGenerated
+                                ? "\n📝 LLM summary generated"
+                                : ""),
+                    });
+                    updateContextFromOrchestrator();
+                    appInterface?.updateContext(chatContext);
+                    return "continue";
+                },
+            },
+            {
+                name: "exit",
+                description: "Exit the session (saves progress)",
+                handler: async () => "exit",
+            },
+            {
+                name: "goto",
+                description: "Direct the agent to a specific URL",
+                handler: async (args, orchestrator) => {
+                    if (args.length === 0) {
+                        getAppInterface()?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: "Usage: /goto <url>",
+                        });
+                        return "continue";
+                    }
+                    const url = args[0];
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: `🚀 Navigating to ${url}...`,
+                    });
+                    void handleUserMessage(`Navigate to ${url} and tell me what you see.`);
+                    return "continue";
+                },
+            },
             {
                 name: "help",
                 description: "Show available slash commands",
@@ -265,56 +411,96 @@ export const chatInk = new Command()
                 },
             },
             {
-                name: "session",
-                description: "Display session metadata and storage path",
-                handler: async () => {
-                    const sessionText = [
-                        `ID: ${chatContext.sessionId}`,
-                        `Path: ${chatContext.sessionPath}`,
-                        `Mode: ${chatContext.mode}`,
-                        `Testing mode: ${chatContext.testingMode}`,
-                    ].join("\n");
+                name: "report",
+                description: "Force the agent to generate a final report",
+                handler: async (args, orchestrator) => {
                     getAppInterface()?.addMessage({
                         id: Date.now().toString(),
                         type: "system",
-                        content: sessionText,
+                        content: "📑 Generating report based on session history...",
                     });
+                    void handleUserMessage("Please generate a final report of your findings for this session.");
                     return "continue";
                 },
             },
             {
-                name: "clear",
-                description: "Clear the terminal and redraw the header",
+                name: "scan",
+                description: "Instruct the agent to scan the page for interactive elements",
                 handler: async () => {
-                    console.clear();
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "🔍 Scanning page for interactive elements...",
+                    });
+                    void handleUserMessage("Scan the current page and list all interactive elements you find.");
                     return "continue";
                 },
             },
             {
-                name: "stop",
-                description: "Stop the assistant (same as ESC)",
+                name: "screenshot",
+                description: "Force the agent to take a screenshot and show the state",
                 handler: async () => {
-                    handleUserCancel();
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "📸 Capturing fresh screenshot...",
+                    });
+                    void handleUserMessage("Please take a screenshot of the current page and tell me what's visible.");
                     return "continue";
                 },
             },
             {
-                name: "cancel",
-                description: "Alias for /stop",
+                name: "where",
+                description: "Get the current URL and page title from the agent",
                 handler: async () => {
-                    handleUserCancel();
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "📍 Checking location...",
+                    });
+                    void handleUserMessage("What is the current URL and page title?");
                     return "continue";
                 },
             },
             {
-                name: "exit",
-                description: "Exit the chat session",
-                handler: async () => "exit",
+                name: "reset",
+                description: "Reset session and clear all messages",
+                handler: async (args, orchestrator) => {
+                    orchestrator.cancel();
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "🧹 Session reset. History cleared.",
+                    });
+                    // Note: In a real app we'd want to tell the orchestrator to reset its internal state too
+                    return "continue";
+                },
             },
             {
-                name: "quit",
-                description: "Alias for /exit",
-                handler: async () => "exit",
+                name: "session",
+                description: "Display session metadata and storage path",
+                handler: async () => {
+                    const sessionText = [
+                        `ID: ${chatContext.sessionId}`,
+                        `Path: ${chatContext.sessionPath}`,
+                        `Mode: ${chatContext.mode}`,
+                        `Testing mode: ${chatContext.testingMode}`,
+                    ].join("\n");
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: sessionText,
+                    });
+                    return "continue";
+                },
+            },
+            {
+                name: "stop",
+                description: "Stop the assistant (same as ESC)",
+                handler: async () => {
+                    handleUserCancel();
+                    return "continue";
+                },
             },
             {
                 name: "logout",
@@ -339,6 +525,108 @@ export const chatInk = new Command()
                     return "exit";
                 },
             },
+            {
+                name: "model",
+                description: "Switch AI model (Pro tier required)",
+                handler: async (args, orchestrator, context) => {
+                    const appInterface = getAppInterface();
+                    try {
+                        const response = await http.get("/api/v1/ai/models");
+                        const data = response.data;
+                        // Check if user can use premium models
+                        const availableModels = data.models.filter((m) => m.available);
+                        const hasPremiumAccess = availableModels.some((m) => m.tier === "premium");
+                        if (!hasPremiumAccess) {
+                            appInterface?.addMessage({
+                                id: Date.now().toString(),
+                                type: "system",
+                                content: "❌ Model switching requires Pro tier. Upgrade at https://timetotest.com/pricing",
+                            });
+                            return "continue";
+                        }
+                        // No args - show available models
+                        if (args.length === 0) {
+                            const modelsList = availableModels
+                                .map((m) => {
+                                const usesInfo = m.usesRemaining !== null
+                                    ? ` (${m.usesRemaining} free uses left)`
+                                    : "";
+                                const creditInfo = m.credits > 0
+                                    ? ` - ${m.credits} credit${m.credits !== 1 ? "s" : ""}/msg`
+                                    : "";
+                                return `  ${m.id} - ${m.name}${creditInfo}${usesInfo}`;
+                            })
+                                .join("\n");
+                            // Show appropriate balance/plan info
+                            const planTier = data.planTier || "free";
+                            const isPaidPlan = planTier !== "free";
+                            const creditBalance = data.creditBalance || 0;
+                            let balanceInfo = "";
+                            if (isPaidPlan) {
+                                // Paid plan users - show plan tier
+                                balanceInfo = `Plan: ${planTier.charAt(0).toUpperCase() + planTier.slice(1)}`;
+                                if (creditBalance > 0) {
+                                    balanceInfo += ` | Extra credits: ${creditBalance}`;
+                                }
+                            }
+                            else {
+                                // Free tier - show credits
+                                balanceInfo = `Credits: ${creditBalance}`;
+                            }
+                            appInterface?.addMessage({
+                                id: Date.now().toString(),
+                                type: "system",
+                                content: `Available Models:\n${modelsList}\n\n${balanceInfo}\n\nUsage: /model <model-id>`,
+                            });
+                            return "continue";
+                        }
+                        // Model switching
+                        const modelId = args[0];
+                        const model = data.models.find((m) => m.id === modelId);
+                        if (!model || !model.available) {
+                            appInterface?.addMessage({
+                                id: Date.now().toString(),
+                                type: "system",
+                                content: model
+                                    ? `❌ ${model.name} is unavailable`
+                                    : `❌ Unknown model: ${modelId}`,
+                            });
+                            return "continue";
+                        }
+                        await orchestrator.setModel(modelId);
+                        // Show appropriate success message
+                        const planTier = data.planTier || "free";
+                        const isPaidPlan = planTier !== "free";
+                        const creditBalance = data.creditBalance || 0;
+                        let statusInfo = "";
+                        if (model.credits > 0) {
+                            if (isPaidPlan) {
+                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? "s" : ""}/msg, ${planTier} plan)`;
+                            }
+                            else if (creditBalance > 0) {
+                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? "s" : ""}/msg, ${creditBalance} credits remaining)`;
+                            }
+                            else {
+                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? "s" : ""}/msg)`;
+                            }
+                        }
+                        appInterface?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `✅ Switched to ${model.name}${statusInfo}`,
+                        });
+                        return "continue";
+                    }
+                    catch (error) {
+                        appInterface?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `❌ Failed: ${error?.message || "Unknown error"}`,
+                        });
+                        return "continue";
+                    }
+                },
+            },
         ];
         const commandMap = new Map(slashCommands.map((command) => [command.name, command.handler]));
         const executeSlashCommand = async (cmd, args) => {
@@ -400,31 +688,71 @@ export const chatInk = new Command()
             }
         };
         const handleExit = () => {
-            console.log(chalk.green("\n✓ Session saved. Run 'ttt resume' to continue."));
+            cleanupOrchestratorListeners();
+            console.error(chalk.green("\n✓ Session saved. Run 'ttt resume' to continue."));
             process.exit(0);
         };
         // Prepare slash commands for the UI
         const slashCommandsForUI = slashCommands.map((cmd) => ({
             name: cmd.name,
             description: cmd.description,
-            value: cmd.name,
+            value: `/${cmd.name}`,
             label: `/${cmd.name}`,
         }));
         // Render the INK app
-        const { waitUntilExit } = render(React.createElement(ChatApp, {
+        const { waitUntilExit, clear } = render(React.createElement(ChatApp, {
             user: userName,
             context: chatContext,
             slashCommands: slashCommandsForUI,
             onUserMessage: handleUserMessage,
             onSlashCommand: executeSlashCommand,
+            onSetTestingMode: async (mode) => {
+                orchestrator.setTestingMode(mode);
+                updateContextFromOrchestrator();
+                getAppInterface()?.updateContext(chatContext);
+                // Save mode preference for next session
+                await configManager.setLastMode(mode);
+            },
             onExit: handleExit,
             onCancel: handleUserCancel,
-        }));
+            initialInput: options.initialInput,
+        }), {
+            stdin: process.stdin,
+            stdout: process.stdout,
+            debug: false,
+            patchConsole: false,
+        });
+        // Clear and re-render on terminal resize to prevent ghosting
+        const handleResize = () => {
+            // Clear entire terminal including scrollback
+            process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+            // Reset Ink's line counter and force re-render
+            clear();
+            // Force a re-render by triggering state change
+            const appInterface = getAppInterface();
+            if (appInterface) {
+                appInterface.setStatus({ text: "", type: "info" });
+                setTimeout(() => appInterface.clearStatus(), 0);
+            }
+        };
+        process.stdout.on("resize", handleResize);
         await waitUntilExit();
+        process.stdout.off("resize", handleResize);
+        cleanupOrchestratorListeners();
     }
     catch (error) {
         console.error(chalk.red(`Error: ${error.message}`));
         process.exit(1);
     }
+}
+export const chatInk = new Command()
+    .name("chat")
+    .description("Start an interactive chat session with the test agent (INK UI). Supports UI testing (browser automation), API testing (HTTP requests), and Code analysis (local file analysis and bug finding).")
+    .option("--mode <mode>", "Testing mode: ui, api, or code", "ui")
+    .option("--base-url <url>", "Base URL for UI testing", process.env.TTT_BASE_URL)
+    .option("--api-base-url <url>", "Base URL for API testing", process.env.TTT_API_BASE_URL)
+    .option("--session <id>", "Resume existing session by ID")
+    .action(async (options) => {
+    await runChatInk(options);
 });
 //# sourceMappingURL=chat-ink.js.map