@timetotest/cli 0.2.4 → 0.3.1

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

@@ -7,36 +7,44 @@ 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();
         if (!token) {
-            try {
-                await performInteractiveLogin();
-                // Update token after authentication
-                token = getAuthToken();
-                if (!token) {
-                    console.error("❌ Authentication failed");
-                    process.exit(1);
-                }
-            }
-            catch (error) {
-                console.error(`❌ Authentication failed: ${error?.message || error}`);
-                process.exit(1);
-            }
+            // Use TUI onboarding instead of direct login
+            // We need to dynamically import OnboardingApp to avoid top-level side effects if possible
+            const { OnboardingApp } = await import("./chat/OnboardingApp.js");
+            // Wrap TUI in a promise to wait for user interaction
+            await new Promise((resolve, reject) => {
+                const { unmount } = render(React.createElement(OnboardingApp, {
+                    onLogin: async () => {
+                        unmount();
+                        try {
+                            await performInteractiveLogin();
+                            // Update token after authentication
+                            token = getAuthToken();
+                            if (!token) {
+                                console.error("❌ Authentication failed");
+                                process.exit(1);
+                            }
+                            resolve();
+                        }
+                        catch (error) {
+                            console.error(`❌ Authentication failed: ${error?.message || error}`);
+                            process.exit(1);
+                        }
+                    },
+                    onExit: () => {
+                        unmount();
+                        process.exit(0);
+                    },
+                }));
+            });
         }
         // Fetch user information
         const { createHttpClient } = await import("../lib/http.js");
@@ -71,19 +79,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)));
@@ -91,7 +107,7 @@ export const chatInk = new Command()
         }
         const config = {
             apiUrl,
-            token,
+            token: token || undefined,
             mode: "local",
             testingMode,
             baseUrl: options.baseUrl,
@@ -102,6 +118,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;
@@ -125,11 +152,12 @@ export const chatInk = new Command()
             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 },
                 });
             }
         };
@@ -139,23 +167,37 @@ export const chatInk = new Command()
             }
             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",
             });
         };
-        const onToolResult = () => {
+        const onToolResult = (data) => {
             if (userCancelled) {
                 return;
             }
-            // Tool completion is intentionally silent now.
+            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) {
@@ -199,8 +241,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",
@@ -275,6 +426,72 @@ export const chatInk = new Command()
                     return "continue";
                 },
             },
+            {
+                name: "report",
+                description: "Force the agent to generate a final report",
+                handler: async (args, orchestrator) => {
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "📑 Generating report based on session history...",
+                    });
+                    void handleUserMessage("Please generate a final report of your findings for this session.");
+                    return "continue";
+                },
+            },
+            {
+                name: "scan",
+                description: "Instruct the agent to scan the page for interactive elements",
+                handler: async () => {
+                    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: "screenshot",
+                description: "Force the agent to take a screenshot and show the state",
+                handler: async () => {
+                    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: "where",
+                description: "Get the current URL and page title from the agent",
+                handler: async () => {
+                    getAppInterface()?.addMessage({
+                        id: Date.now().toString(),
+                        type: "system",
+                        content: "📍 Checking location...",
+                    });
+                    void handleUserMessage("What is the current URL and page title?");
+                    return "continue";
+                },
+            },
+            {
+                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: "session",
                 description: "Display session metadata and storage path",
@@ -293,14 +510,6 @@ export const chatInk = new Command()
                     return "continue";
                 },
             },
-            {
-                name: "clear",
-                description: "Clear the terminal and redraw the header",
-                handler: async () => {
-                    console.clear();
-                    return "continue";
-                },
-            },
             {
                 name: "stop",
                 description: "Stop the assistant (same as ESC)",
@@ -310,23 +519,28 @@ export const chatInk = new Command()
                 },
             },
             {
-                name: "cancel",
-                description: "Alias for /stop",
+                name: "logout",
+                description: "Log out and clear local credentials",
                 handler: async () => {
-                    handleUserCancel();
-                    return "continue";
+                    try {
+                        const { clearAuthToken } = await import("../lib/config.js");
+                        clearAuthToken();
+                        getAppInterface()?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: "✅ Logged out. Credentials cleared.",
+                        });
+                    }
+                    catch (e) {
+                        getAppInterface()?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `❌ Failed to logout: ${e?.message || String(e)}`,
+                        });
+                    }
+                    return "exit";
                 },
             },
-            {
-                name: "exit",
-                description: "Exit the chat session",
-                handler: async () => "exit",
-            },
-            {
-                name: "quit",
-                description: "Alias for /exit",
-                handler: async () => "exit",
-            },
             {
                 name: "model",
                 description: "Switch AI model (Pro tier required)",
@@ -350,8 +564,12 @@ export const chatInk = new Command()
                         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` : "";
+                                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");
@@ -385,7 +603,9 @@ export const chatInk = new Command()
                             appInterface?.addMessage({
                                 id: Date.now().toString(),
                                 type: "system",
-                                content: model ? `❌ ${model.name} is unavailable` : `❌ Unknown model: ${modelId}`,
+                                content: model
+                                    ? `❌ ${model.name} is unavailable`
+                                    : `❌ Unknown model: ${modelId}`,
                             });
                             return "continue";
                         }
@@ -397,13 +617,13 @@ export const chatInk = new Command()
                         let statusInfo = "";
                         if (model.credits > 0) {
                             if (isPaidPlan) {
-                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? 's' : ''}/msg, ${planTier} plan)`;
+                                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)`;
+                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? "s" : ""}/msg, ${creditBalance} credits remaining)`;
                             }
                             else {
-                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? 's' : ''}/msg)`;
+                                statusInfo = ` (${model.credits} credit${model.credits !== 1 ? "s" : ""}/msg)`;
                             }
                         }
                         appInterface?.addMessage({
@@ -423,29 +643,6 @@ export const chatInk = new Command()
                     }
                 },
             },
-            {
-                name: "logout",
-                description: "Log out and clear local credentials",
-                handler: async () => {
-                    try {
-                        const { clearAuthToken } = await import("../lib/config.js");
-                        clearAuthToken();
-                        getAppInterface()?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: "✅ Logged out. Credentials cleared.",
-                        });
-                    }
-                    catch (e) {
-                        getAppInterface()?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: `❌ Failed to logout: ${e?.message || String(e)}`,
-                        });
-                    }
-                    return "exit";
-                },
-            },
         ];
         const commandMap = new Map(slashCommands.map((command) => [command.name, command.handler]));
         const executeSlashCommand = async (cmd, args) => {
@@ -508,7 +705,7 @@ export const chatInk = new Command()
         };
         const handleExit = () => {
             cleanupOrchestratorListeners();
-            console.log(chalk.green("\n✓ Session saved. Run 'ttt resume' to continue."));
+            console.error(chalk.green("\n✓ Session saved. Run 'ttt resume' to continue."));
             process.exit(0);
         };
         // Prepare slash commands for the UI
@@ -519,21 +716,59 @@ export const chatInk = new Command()
             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