@timetotest/cli 0.1.1

package/dist/src/commands/ask.js

@@ -0,0 +1,864 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import os from "node:os";
+import { createHttpClient } from "../lib/http.js";
+import { connectAndSubscribe } from "../lib/socket.js";
+import { promptInBox, printDivider, formatStatusSegments, accentText, highlightText, printBanner, } from "../lib/tui.js";
+import { getAuthToken, getUserLastProject, setUserLastProject, } from "../lib/config.js";
+import { performInteractiveLogin } from "./login.js";
+function formatResponseText(text) {
+    if (!text)
+        return text;
+    // Convert HTML-like tags to CLI-friendly formatting
+    let formatted = text
+        // Convert <list> to a simple list
+        .replace(/<list>/g, "")
+        .replace(/<\/list>/g, "")
+        // Convert <item> to bullet points
+        .replace(/<item>/g, "• ")
+        .replace(/<\/item>/g, "")
+        // Convert <strong> to bold
+        .replace(/<strong>/g, chalk.bold(""))
+        .replace(/<\/strong>/g, chalk.reset(""))
+        // Convert <em> to italic
+        .replace(/<em>/g, chalk.italic(""))
+        .replace(/<\/em>/g, chalk.reset(""))
+        // Convert <code> to monospace
+        .replace(/<code>/g, chalk.gray(""))
+        .replace(/<\/code>/g, chalk.reset(""))
+        // Convert line breaks to proper newlines
+        .replace(/\n/g, "\n");
+    return formatted;
+}
+export const ask = new Command("ask")
+    .description("Start interactive chat with TimetoTest AI agent")
+    .option("--project-id <id>", "Project ID to use for the conversation")
+    .option("--conversation-id <id>", "Continue existing conversation")
+    .action(async (opts) => {
+    try {
+        // Check authentication
+        const token = getAuthToken();
+        if (!token) {
+            console.log(chalk.yellow("You are not logged in. Opening browser to authenticate…"));
+            try {
+                await performInteractiveLogin();
+            }
+            catch (e) {
+                console.log(chalk.red(e?.message || "Login failed"));
+                process.exit(1);
+            }
+        }
+        let http = createHttpClient();
+        const drawIntro = () => {
+            console.clear();
+            printBanner();
+            console.log(chalk.white("Tips for getting started:"));
+            console.log(`${chalk.dim("1.")} ${chalk.white("Ask questions, inspect files, or run commands.")}`);
+            console.log(`${chalk.dim("2.")} ${chalk.white("Be specific for the clearest answers.")}`);
+            console.log(`${chalk.dim("3.")} ${chalk.white(`Share extra context with ${accentText("@path/to/file")}.`)}`);
+            console.log(`${chalk.dim("4.")} ${chalk.white(`${accentText("/help")} shows slash commands and shortcuts.`)}`);
+            console.log();
+        };
+        // Gemini-like intro: banner + tips, then single active input box (no duplicate)
+        drawIntro();
+        let conversationId = opts.conversationId;
+        let projectId;
+        if (opts.projectId !== undefined) {
+            const parsedProjectId = Number(opts.projectId);
+            if (!Number.isInteger(parsedProjectId)) {
+                console.log(chalk.red(`❌ Invalid project id '${opts.projectId}'. Please provide a numeric value.`));
+                process.exit(1);
+            }
+            projectId = parsedProjectId;
+        }
+        let sessionInfoWarningShown = false;
+        let lastKnownUser = "Unknown";
+        let lastKnownUserKey;
+        let lastKnownProject = projectId ? `Project ${projectId}` : "Not set";
+        const renderSessionSummary = async (refresh = true, retried = false) => {
+            if (refresh) {
+                try {
+                    const userResp = await http.get("/api/v1/auth/me");
+                    lastKnownUserKey =
+                        userResp.data.email || String(userResp.data.user_id || "");
+                    lastKnownUser =
+                        userResp.data.email || userResp.data.display_name || "Unknown";
+                    if (projectId) {
+                        const projectResp = await http.get(`/api/v1/projects/${projectId}`);
+                        lastKnownProject =
+                            projectResp.data.name || `Project ${projectId}`;
+                    }
+                    else {
+                        lastKnownProject = "Not set";
+                    }
+                    sessionInfoWarningShown = false;
+                }
+                catch (error) {
+                    if (!retried) {
+                        // Attempt to re-auth then retry once
+                        const msg = chalk.gray("Re-authenticating to refresh session information…");
+                        console.log(msg);
+                        try {
+                            await performInteractiveLogin();
+                            http = createHttpClient();
+                            await renderSessionSummary(true, true);
+                            return;
+                        }
+                        catch (reauthErr) {
+                            // fall through to warning message below
+                        }
+                    }
+                    if (!sessionInfoWarningShown) {
+                        console.log(chalk.gray("ℹ️  Unable to refresh session info from the API."));
+                        sessionInfoWarningShown = true;
+                    }
+                }
+            }
+            console.log(`${chalk.gray("Signed in as")} ${chalk.white(lastKnownUser)}`);
+            console.log(`${chalk.gray("Project")} ${accentText(lastKnownProject)} ${chalk.gray("· use /switch to change")}`);
+            console.log();
+        };
+        let spinner = null;
+        let messageCount = 1;
+        let socket;
+        // Function to switch projects
+        const switchProject = async (searchTerm) => {
+            try {
+                const fetchSpinner = ora("Fetching your projects...").start();
+                const projectsResp = await http.get("/api/v1/projects");
+                const projectsRaw = projectsResp.data;
+                const projects = Array.isArray(projectsRaw?.items)
+                    ? projectsRaw.items
+                    : Array.isArray(projectsRaw)
+                        ? projectsRaw
+                        : [];
+                fetchSpinner.succeed("Projects loaded!");
+                if (!projects || projects.length === 0) {
+                    console.log(chalk.yellow("❌ No projects available."));
+                    return;
+                }
+                const findProject = (query) => {
+                    const normalized = query.trim().toLowerCase();
+                    return projects.find((project) => {
+                        if (!project)
+                            return false;
+                        const name = String(project.name || "").toLowerCase();
+                        const idMatch = String(project.id || "") === query.trim();
+                        return idMatch || name.includes(normalized);
+                    });
+                };
+                let selectedProject;
+                if (searchTerm && searchTerm.trim().length > 0) {
+                    selectedProject = findProject(searchTerm.trim());
+                    if (!selectedProject) {
+                        console.log(chalk.yellow(`No project matched "${searchTerm}". Showing the list instead.`));
+                    }
+                }
+                if (!selectedProject) {
+                    console.log();
+                    printDivider("Available Projects");
+                    projects.forEach((project, index) => {
+                        const isCurrent = project.id === projectId;
+                        const marker = isCurrent ? chalk.green("●") : chalk.gray("○");
+                        console.log(`${marker} ${chalk.cyan(project.name)}`);
+                        console.log(`   ${chalk.gray(project.description || "No description")}`);
+                        if (index < projects.length - 1)
+                            console.log();
+                    });
+                    printDivider();
+                    const { value: selection, aborted } = await promptInBox({
+                        label: "Switch Project",
+                        placeholder: "Start typing a project name or ID...",
+                        hint: "Enter to switch · leave empty to cancel",
+                        infoLines: [
+                            chalk.gray("Matching is case-insensitive and accepts partial names."),
+                            chalk.gray("Press Ctrl+C to cancel the switch."),
+                        ],
+                    });
+                    if (aborted || selection.length === 0) {
+                        console.log(chalk.gray("Project switch cancelled."));
+                        return;
+                    }
+                    selectedProject = findProject(selection);
+                    if (!selectedProject) {
+                        console.log(chalk.red(`❌ Project "${selection}" not found.`));
+                        return;
+                    }
+                }
+                if (!selectedProject) {
+                    console.log(chalk.red("❌ Unable to determine project."));
+                    return;
+                }
+                if (selectedProject.id === projectId) {
+                    console.log(chalk.yellow(`ℹ️  Already on project "${selectedProject.name}".`));
+                    return;
+                }
+                projectId = selectedProject.id;
+                lastKnownProject = selectedProject.name || `Project ${projectId}`;
+                conversationId = undefined;
+                messageCount = 1;
+                // Do not create a conversation yet; wait for the next user message
+                if (socket) {
+                    try {
+                        socket.removeAllListeners?.();
+                        await socket.disconnect();
+                    }
+                    catch (disconnectError) {
+                        console.log(chalk.gray(`ℹ️  Reconnecting socket: ${disconnectError?.message || disconnectError}`));
+                    }
+                }
+                if (lastKnownUserKey && typeof projectId === "number") {
+                    setUserLastProject(lastKnownUserKey, projectId);
+                }
+                await renderSessionSummary();
+                console.log(chalk.green(`✅ Switched to project: ${selectedProject.name}`));
+                console.log();
+            }
+            catch (error) {
+                console.log(chalk.red(`❌ Failed to switch project: ${error?.message || error}`));
+            }
+        };
+        const slashCommands = [];
+        const helpCommand = {
+            name: "help",
+            description: "Show available slash commands",
+            aliases: ["?", "commands", "h"],
+            run: async () => {
+                console.log(chalk.white("Slash commands:"));
+                slashCommands.forEach((cmd) => {
+                    const aliasText = cmd.aliases?.length
+                        ? chalk.gray(` (aliases: ${cmd.aliases
+                            .map((alias) => `/${alias}`)
+                            .join(", ")})`)
+                        : "";
+                    console.log(`  ${accentText(`/${cmd.name}`)} ${chalk.gray(cmd.description)}${aliasText}`);
+                });
+                console.log(chalk.gray("Prefix commands with '/' (for example, /switch or /summary)."));
+                console.log();
+                return "continue";
+            },
+        };
+        const summaryCommand = {
+            name: "summary",
+            description: "Display the latest session information",
+            aliases: ["session", "status"],
+            run: async () => {
+                await renderSessionSummary();
+                return "continue";
+            },
+        };
+        const switchCommand = {
+            name: "switch",
+            description: "Switch to a different project",
+            aliases: ["project", "s"],
+            run: async (args) => {
+                const query = args.join(" ");
+                await switchProject(query);
+                return "continue";
+            },
+        };
+        const clearCommand = {
+            name: "clear",
+            description: "Clear the screen and redraw the header",
+            aliases: ["cls"],
+            run: async () => {
+                drawIntro();
+                await renderSessionSummary(false);
+                return "continue";
+            },
+        };
+        const projectsCommand = {
+            name: "projects",
+            description: "List your projects",
+            aliases: ["list-projects", "proj"],
+            run: async () => {
+                try {
+                    const resp = await http.get("/api/v1/projects");
+                    const items = Array.isArray(resp.data?.items)
+                        ? resp.data.items
+                        : Array.isArray(resp.data)
+                            ? resp.data
+                            : [];
+                    if (!items.length) {
+                        console.log(chalk.yellow("No projects found."));
+                        return "continue";
+                    }
+                    console.log();
+                    printDivider("Projects");
+                    items.forEach((p, i) => {
+                        const isCurrent = p.id === projectId;
+                        const marker = isCurrent ? chalk.green("●") : chalk.gray("○");
+                        const name = p.name || `Project ${p.id}`;
+                        const def = p.is_default ? chalk.cyan(" (default)") : "";
+                        console.log(`${marker} ${chalk.cyan(name)}${def}`);
+                        console.log(`   ${chalk.gray(p.description || "No description")}`);
+                        if (i < items.length - 1)
+                            console.log();
+                    });
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to list projects: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const testsCommand = {
+            name: "tests",
+            description: "List recent tests",
+            aliases: ["list-tests"],
+            run: async () => {
+                try {
+                    const params = projectId ? `?project_id=${projectId}` : "";
+                    const resp = await http.get(`/api/v1/my-tests${params}`);
+                    const items = Array.isArray(resp.data?.items)
+                        ? resp.data.items
+                        : Array.isArray(resp.data)
+                            ? resp.data
+                            : [];
+                    if (!items.length) {
+                        console.log(chalk.yellow("No tests yet."));
+                        return "continue";
+                    }
+                    console.log();
+                    printDivider("Tests");
+                    items.forEach((t, i) => {
+                        const id = t.id;
+                        const status = t.status || "";
+                        const url = t.url || "";
+                        const type = t.test_type || "";
+                        console.log(`${chalk.gray("•")} ${chalk.white(`#${id}`)} ${chalk.gray(`(${type} · ${status})`)} ${chalk.cyan(url)}`);
+                        if (i < items.length - 1)
+                            console.log();
+                    });
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to list tests: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const statusCommand = {
+            name: "status",
+            description: "Get test status: /status <testId>",
+            aliases: ["test-status"],
+            run: async (args) => {
+                const id = Number(args[0]);
+                if (!id || Number.isNaN(id)) {
+                    console.log(chalk.yellow("Usage: /status <testId>"));
+                    return "continue";
+                }
+                try {
+                    const resp = await http.get(`/api/v1/tests/${id}/status`);
+                    const s = resp.data;
+                    console.log();
+                    printDivider(`Test #${id} Status`);
+                    console.log(formatStatusSegments([
+                        { label: "status", value: s.status, color: chalk.cyan },
+                        {
+                            label: "progress",
+                            value: `${s.progress_percentage}%`,
+                            color: chalk.green,
+                        },
+                        {
+                            label: "stage",
+                            value: s.current_stage || s.currentStage || "",
+                            color: chalk.white,
+                        },
+                    ]));
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to get status: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const reportCommand = {
+            name: "report",
+            description: "Generate a report: /report <testId> [html|json]",
+            aliases: ["make-report"],
+            run: async (args) => {
+                const id = Number(args[0]);
+                const fmt = (args[1] || "html").toLowerCase();
+                if (!id || Number.isNaN(id)) {
+                    console.log(chalk.yellow("Usage: /report <testId> [html|json]"));
+                    return "continue";
+                }
+                try {
+                    const resp = await http.get(`/api/v1/reports/`, {
+                    // axios get with params? route is POST /reports/, but it expects query params via function signature
+                    });
+                }
+                catch (_) {
+                    // Fallback to POST with query params as defined in backend
+                }
+                try {
+                    const resp = await http.post(`/api/v1/reports/`, null, {
+                        params: { test_id: id, report_format: fmt },
+                    });
+                    const r = resp.data;
+                    console.log();
+                    printDivider(`Report for Test #${id}`);
+                    console.log(`${chalk.gray("report id")} ${chalk.white(r.id)}`);
+                    if (r.file_path)
+                        console.log(`${chalk.gray("file")} ${chalk.cyan(r.file_path)}`);
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to generate report: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const startTestCommand = {
+            name: "test",
+            description: "Start a test: /test <url> [ui|api]",
+            aliases: ["start-test", "start"],
+            run: async (args) => {
+                let url = args.find((a) => a.startsWith("http")) || "";
+                let type = (args.find((a) => a === "ui" || a === "api") || "ui").toLowerCase();
+                if (!url) {
+                    const { value, aborted } = await promptInBox({
+                        label: "Start Test",
+                        placeholder: "Enter site URL (https://...)",
+                        hint: "Enter to confirm · Ctrl+C to cancel",
+                        fullWidth: true,
+                    });
+                    if (aborted || !value.trim())
+                        return "continue";
+                    url = value.trim();
+                }
+                if (type !== "ui" && type !== "api")
+                    type = "ui";
+                try {
+                    const resp = await http.post(`/api/v1/start-test`, {
+                        url,
+                        test_type: type,
+                        project_id: projectId,
+                        user_prompt: `CLI start test for ${url}`,
+                    });
+                    const data = resp.data;
+                    console.log();
+                    printDivider("Test Started");
+                    console.log(formatStatusSegments([
+                        { label: "id", value: String(data.test_id), color: chalk.white },
+                        { label: "status", value: data.status, color: chalk.cyan },
+                        {
+                            label: "project",
+                            value: lastKnownProject,
+                            color: highlightText,
+                        },
+                    ]));
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to start test: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const conversationsCommand = {
+            name: "conversations",
+            description: "List your recent conversations",
+            aliases: ["convos", "sessions"],
+            run: async () => {
+                try {
+                    const params = projectId ? `?project_id=${projectId}` : "";
+                    const resp = await http.get(`/api/v1/ask/sessions${params}`);
+                    const items = Array.isArray(resp.data?.items)
+                        ? resp.data.items
+                        : Array.isArray(resp.data)
+                            ? resp.data
+                            : [];
+                    if (!items.length) {
+                        console.log(chalk.yellow("No conversations yet."));
+                        return "continue";
+                    }
+                    console.log();
+                    printDivider("Conversations");
+                    items.forEach((c, i) => {
+                        const id = c.conversation_id || c.execution_id || c.id;
+                        const created = c.created_at || "";
+                        const status = c.status || "";
+                        const title = c.goal || c.title || "";
+                        console.log(`${chalk.gray("•")} ${chalk.white(title || id)} ${chalk.gray(`(${status})`)}`);
+                        if (created)
+                            console.log(`   ${chalk.gray(created)}`);
+                        if (i < items.length - 1)
+                            console.log();
+                    });
+                    printDivider();
+                }
+                catch (e) {
+                    console.log(chalk.red(`❌ Failed to list conversations: ${e?.message || e}`));
+                }
+                return "continue";
+            },
+        };
+        const exitCommand = {
+            name: "exit",
+            description: "End the conversation",
+            aliases: ["quit", "bye"],
+            run: async () => "exit",
+        };
+        slashCommands.push(helpCommand, summaryCommand, switchCommand, clearCommand, testsCommand, statusCommand, reportCommand, startTestCommand, projectsCommand, conversationsCommand, exitCommand);
+        const commandLookup = new Map();
+        slashCommands.forEach((command) => {
+            commandLookup.set(command.name, command);
+            command.aliases?.forEach((alias) => {
+                commandLookup.set(alias, command);
+            });
+        });
+        const executeSlashCommand = async (rawInput) => {
+            const trimmed = rawInput.trim();
+            if (!trimmed) {
+                console.log(chalk.gray("Type / to see the command list."));
+                return "continue";
+            }
+            const [keyword, ...rawArgs] = trimmed.split(/\s+/);
+            const command = commandLookup.get(keyword.toLowerCase());
+            if (!command) {
+                console.log(chalk.yellow(`Unknown command: /${keyword}`));
+                console.log(chalk.gray(`Type / to see available commands.`));
+                return "continue";
+            }
+            return await command.run(rawArgs);
+        };
+        // Load session summary without creating conversation yet
+        const summarySpinner = ora("Loading session info...").start();
+        // Auto-select last used project for this user, else default
+        try {
+            const me = await http.get("/api/v1/auth/me");
+            lastKnownUserKey = me.data?.email || String(me.data?.user_id || "");
+            if (!projectId && lastKnownUserKey) {
+                const remembered = getUserLastProject(lastKnownUserKey);
+                if (remembered) {
+                    projectId = remembered;
+                }
+            }
+            // Fetch user's projects and pick the default if present; otherwise the most recent
+            const projectsResp = await http.get("/api/v1/projects");
+            const projectsRaw = projectsResp.data;
+            const projects = Array.isArray(projectsRaw?.items)
+                ? projectsRaw.items
+                : Array.isArray(projectsRaw)
+                    ? projectsRaw
+                    : [];
+            if (!projectId && projects && projects.length > 0) {
+                const defaultProj = projects.find((p) => p?.is_default === true);
+                const selected = defaultProj || projects[0];
+                if (selected?.id) {
+                    projectId = selected.id;
+                    lastKnownProject = selected.name || `Project ${projectId}`;
+                }
+            }
+            // If we loaded a remembered project, populate the name proactively
+            if (projectId &&
+                (!lastKnownProject || lastKnownProject === "Not set")) {
+                try {
+                    const p = await http.get(`/api/v1/projects/${projectId}`);
+                    lastKnownProject = p.data?.name || `Project ${projectId}`;
+                }
+                catch { }
+            }
+        }
+        catch (_) {
+            // non-fatal; continue without preselecting
+        }
+        await renderSessionSummary();
+        summarySpinner.succeed("Ready to chat.");
+        const attachSocketHandlers = (socketInstance) => {
+            socketInstance.on("ASK_THINKING_STARTED", () => {
+                if (spinner) {
+                    spinner.text = chalk.cyan("🤔 Thinking...");
+                }
+            });
+            socketInstance.on("ASK_THINKING_STOPPED", () => {
+                // Thinking stopped, ready for next input
+            });
+            socketInstance.on("ASK_TOOL_START", (data) => {
+                const message = data.data?.message || `Running ${data.data?.tool || "tool"}...`;
+                if (spinner) {
+                    spinner.text = chalk.blue(`⚙️  ${message}`);
+                }
+            });
+            socketInstance.on("ASK_TOOL_RESULT", (data) => {
+                const message = data.data?.message || `Completed ${data.data?.tool || "tool"}`;
+                console.log(chalk.green(`✅ ${message}`));
+            });
+            // Note: ASK_AGENT_ANSWER is handled by ASK_SESSION_COMPLETED to avoid duplicates
+            socketInstance.on("ASK_SESSION_COMPLETED", (data) => {
+                if (spinner) {
+                    spinner.stop();
+                    spinner = null;
+                }
+                console.log();
+                printDivider("Assistant");
+                const summary = data.data?.summary || "No response";
+                console.log(formatResponseText(summary));
+                printDivider();
+                console.log();
+            });
+            socketInstance.on("ASK_SESSION_ERROR", (data) => {
+                if (spinner) {
+                    spinner.fail("An error occurred");
+                    spinner = null;
+                }
+                printDivider("Assistant Error");
+                console.log(chalk.red(`❌ ${data.data?.error || "Unknown error"}`));
+                printDivider();
+                console.log();
+            });
+        };
+        const establishSocket = (conversation) => {
+            const newSocket = connectAndSubscribe(conversation);
+            attachSocketHandlers(newSocket);
+            return newSocket;
+        };
+        if (conversationId) {
+            socket = establishSocket(conversationId);
+        }
+        // Main conversation loop
+        const workspacePath = process.cwd();
+        const homeDir = os.homedir();
+        const displayPath = workspacePath.startsWith(homeDir)
+            ? `~${workspacePath.slice(homeDir.length)}`
+            : workspacePath;
+        while (true) {
+            // Show input box for user message
+            const firstMessage = messageCount === 1;
+            const statusLine = formatStatusSegments([
+                { label: "path", value: displayPath, color: accentText },
+                { label: "project", value: lastKnownProject, color: highlightText },
+            ]);
+            // Removed usage line per request
+            // Removed extra hint to keep UI clean
+            const getSlashSuggestions = (input) => {
+                const q = (input || "").replace(/^\//, "").toLowerCase();
+                const priority = {
+                    test: 0,
+                    switch: 1,
+                    status: 2,
+                };
+                const items = slashCommands
+                    .map((c) => ({
+                    label: `/${c.name}`,
+                    value: c.name,
+                    description: c.description,
+                    p: priority[c.name] ?? 100,
+                }))
+                    .sort((a, b) => a.p - b.p || a.value.localeCompare(b.value));
+                if (!q)
+                    return items;
+                return items
+                    .filter((i) => i.value.toLowerCase().startsWith(q) ||
+                    i.label.toLowerCase().includes(q))
+                    .sort((a, b) => a.p - b.p || a.value.localeCompare(b.value));
+            };
+            const { value, aborted } = await promptInBox({
+                placeholder: "Type your message or @path/to/file",
+                footerLines: [statusLine],
+                fullWidth: true,
+                getSuggestions: getSlashSuggestions,
+            });
+            if (aborted) {
+                console.log(chalk.gray("Session cancelled."));
+                break;
+            }
+            const userInput = value.trim();
+            const normalizedInput = userInput.toLowerCase();
+            if (!userInput) {
+                console.log(chalk.yellow("Please enter a message or type /exit to leave."));
+                continue;
+            }
+            if (normalizedInput === "exit" || normalizedInput === "quit") {
+                console.log(chalk.gray("Goodbye! 👋"));
+                break;
+            }
+            const legacyCommand = {
+                help: "help",
+                commands: "help",
+                "?": "help",
+                summary: "summary",
+                status: "summary",
+                switch: "switch",
+                clear: "clear",
+                cls: "clear",
+            }[normalizedInput];
+            if (legacyCommand) {
+                console.log(chalk.gray("Tip: commands work best with '/'. Running it for you now..."));
+                const outcome = await executeSlashCommand(legacyCommand);
+                if (outcome === "exit") {
+                    console.log(chalk.gray("Goodbye! 👋"));
+                    break;
+                }
+                continue;
+            }
+            if (userInput.startsWith("/")) {
+                const outcome = await executeSlashCommand(userInput.slice(1));
+                if (outcome === "exit") {
+                    console.log(chalk.gray("Goodbye! 👋"));
+                    break;
+                }
+                continue;
+            }
+            // Create conversation and establish socket on first message
+            if (!conversationId) {
+                spinner = ora("Creating conversation...").start();
+                try {
+                    const sessionResp = await http.post("/api/v1/ask/sessions", {
+                        question: userInput,
+                        project_id: projectId,
+                        surface: "cli",
+                    });
+                    conversationId = sessionResp.data.conversation_id;
+                    projectId = sessionResp.data.project_id;
+                    if (lastKnownUserKey && typeof projectId === "number") {
+                        setUserLastProject(lastKnownUserKey, projectId);
+                    }
+                    // Establish socket connection
+                    socket = establishSocket(conversationId);
+                    spinner.text = "Waiting for assistant...";
+                }
+                catch (e) {
+                    const status = e?.response?.status;
+                    if (status === 401) {
+                        spinner.text = "Session expired. Re-authenticating...";
+                        await performInteractiveLogin();
+                        http = createHttpClient();
+                        spinner.text = "Creating conversation...";
+                        const sessionResp = await http.post("/api/v1/ask/sessions", {
+                            question: userInput,
+                            project_id: projectId,
+                            surface: "cli",
+                        });
+                        conversationId = sessionResp.data.conversation_id;
+                        projectId = sessionResp.data.project_id;
+                        if (lastKnownUserKey && typeof projectId === "number") {
+                            setUserLastProject(lastKnownUserKey, projectId);
+                        }
+                        // Establish socket connection
+                        socket = establishSocket(conversationId);
+                        spinner.text = "Waiting for assistant...";
+                    }
+                    else {
+                        spinner.fail("Failed to create conversation");
+                        throw e;
+                    }
+                }
+            }
+            else {
+                // Send question to existing conversation
+                spinner = ora("Sending...").start();
+                try {
+                    await http.post(`/api/v1/ask/sessions/${conversationId}/message`, {
+                        message: userInput,
+                        project_id: projectId,
+                        surface: "cli",
+                    });
+                    spinner.text = "Waiting for assistant...";
+                }
+                catch (e) {
+                    const status = e?.response?.status;
+                    if (status === 401) {
+                        spinner.text = "Session expired. Re-authenticating...";
+                        await performInteractiveLogin();
+                        http = createHttpClient();
+                        spinner.text = "Sending...";
+                        await http.post(`/api/v1/ask/sessions/${conversationId}/message`, {
+                            message: userInput,
+                            project_id: projectId,
+                            surface: "cli",
+                        });
+                        spinner.text = "Waiting for assistant...";
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            // Create a promise that resolves when agent responds
+            const waitForResponse = new Promise((resolve) => {
+                const responseHandler = (data) => {
+                    // Remove the listener once we get a response
+                    socket.off("ASK_SESSION_COMPLETED", responseHandler);
+                    socket.off("ASK_SESSION_ERROR", errorHandler);
+                    resolve();
+                };
+                const errorHandler = (data) => {
+                    // Remove the listener once we get an error
+                    socket.off("ASK_SESSION_COMPLETED", responseHandler);
+                    socket.off("ASK_SESSION_ERROR", errorHandler);
+                    resolve();
+                };
+                // Listen for agent response
+                socket.on("ASK_SESSION_COMPLETED", responseHandler);
+                socket.on("ASK_SESSION_ERROR", errorHandler);
+            });
+            let messageDelivered = false;
+            try {
+                // Wait for the agent response before continuing
+                await waitForResponse;
+                messageDelivered = true;
+            }
+            catch (error) {
+                if (spinner) {
+                    spinner.fail();
+                    spinner = null;
+                }
+                const status = error?.response?.status;
+                if (status === 401) {
+                    console.log(chalk.yellow("Session expired. Re-authenticating…"));
+                    try {
+                        await performInteractiveLogin();
+                    }
+                    catch (loginError) {
+                        console.log(chalk.red(loginError?.message || "Re-authentication failed."));
+                        break;
+                    }
+                    http = createHttpClient();
+                    spinner = ora("Sending...").start();
+                    try {
+                        await http.post(`/api/v1/ask/sessions/${conversationId}/message`, {
+                            message: userInput,
+                            project_id: projectId,
+                            surface: "cli",
+                        });
+                        spinner.text = "Waiting for assistant...";
+                        // Wait for response even after re-auth
+                        await waitForResponse;
+                        messageDelivered = true;
+                    }
+                    catch (err2) {
+                        if (spinner) {
+                            spinner.fail();
+                            spinner = null;
+                        }
+                        console.log(chalk.red(`❌ Error sending message: ${err2?.message || err2}`));
+                    }
+                }
+                else {
+                    console.log(chalk.red(`❌ Error sending message: ${error?.message || error}`));
+                }
+            }
+            if (messageDelivered) {
+                messageCount += 1;
+            }
+        }
+        // Clean up
+        if (spinner) {
+            spinner.stop();
+        }
+        if (socket) {
+            await socket.disconnect();
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`❌ Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=ask.js.map