gemiterm 2.1.1 → 2.2.0-beta.1

package/src/cli/commands/export-all-command.ts

@@ -16,7 +16,7 @@ import { joinPath, resolvePath } from "../../infrastructure/path-utils.ts";
 
 interface ExportAllCommandOptions {
   help: boolean;
-  outputDir: string;
+  outDir: string;
   since: string;
   includeMetadata: boolean;
   allProfiles: boolean;
@@ -24,7 +24,7 @@ interface ExportAllCommandOptions {
 
 const DEFAULT_OPTIONS: ExportAllCommandOptions = {
   help: false,
-  outputDir: "./exports",
+  outDir: "./exports",
   since: "",
   includeMetadata: false,
   allProfiles: false,
@@ -75,8 +75,8 @@ export class ExportAllCommand implements CliCommand {
       console.log(chalk.bold(`Found ${chats.length} conversation${chats.length !== 1 ? "s" : ""} to export.`));
       console.log("");
 
-      const outputDir = resolvePath(options.outputDir);
-      ensureDir(outputDir);
+      const outDir = resolvePath(options.outDir);
+      ensureDir(outDir);
 
       const results: ExportResult[] = [];
 
@@ -92,7 +92,7 @@ export class ExportAllCommand implements CliCommand {
           } as Query<FetchChatQueryPayload>);
 
           const filename = this.sanitizeFilename(chat.title || chat.id);
-          const filePath = joinPath(outputDir, `${filename}.md`);
+          const filePath = joinPath(outDir, `${filename}.md`);
           const content = formatChatAsMarkdown(
             fetchResult.messages,
             chat.title,
@@ -112,8 +112,8 @@ export class ExportAllCommand implements CliCommand {
         }
       }
 
-      this.writeIndex(outputDir, results, options.includeMetadata);
-      this.printSummary(results, outputDir);
+      this.writeIndex(outDir, results, options.includeMetadata);
+      this.printSummary(results, outDir);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.error(chalk.red(`Error: ${message}`));
@@ -138,7 +138,7 @@ export class ExportAllCommand implements CliCommand {
     return `gemini-chat-${safe}-${date}`.replace(/-+$/, "");
   }
 
-  private writeIndex(outputDir: string, results: ExportResult[], includeMetadata: boolean): void {
+  private writeIndex(outDir: string, results: ExportResult[], includeMetadata: boolean): void {
     const lines: string[] = [];
 
     lines.push("# Exported Conversations");
@@ -173,11 +173,11 @@ export class ExportAllCommand implements CliCommand {
       }
     }
 
-    const indexPath = joinPath(outputDir, "index.md");
+    const indexPath = joinPath(outDir, "index.md");
     writeTextFile(indexPath, lines.join("\n"));
   }
 
-  private printSummary(results: ExportResult[], outputDir: string): void {
+  private printSummary(results: ExportResult[], outDir: string): void {
     const succeeded = results.filter((r) => r.success);
     const failed = results.filter((r) => !r.success);
 
@@ -187,8 +187,8 @@ export class ExportAllCommand implements CliCommand {
     if (failed.length > 0) {
       console.log(`  Failed:  ${chalk.red(failed.length)}`);
     }
-    console.log(`  Output:  ${outputDir}`);
-    console.log(`  Index:   ${chalk.cyan(joinPath(outputDir, "index.md"))}`);
+    console.log(`  Output:  ${outDir}`);
+    console.log(`  Index:   ${chalk.cyan(joinPath(outDir, "index.md"))}`);
   }
 
   private parseArgs(args: string[]): ExportAllCommandOptions {
@@ -201,9 +201,9 @@ export class ExportAllCommand implements CliCommand {
         case "-h":
           options.help = true;
           break;
-        case "--output-dir":
+        case "--out-dir":
         case "-o":
-          options.outputDir = args[++i] ?? DEFAULT_OPTIONS.outputDir;
+          options.outDir = args[++i] ?? DEFAULT_OPTIONS.outDir;
           break;
         case "--since":
           options.since = args[++i] ?? "";
@@ -227,7 +227,7 @@ export class ExportAllCommand implements CliCommand {
     console.log(chalk.bold("Options:"));
 
     const flags = [
-      { flag: "--output-dir, -o <dir>", desc: "Output directory (default: ./exports)" },
+      { flag: "--out-dir, -o <dir>", desc: "Output directory (default: ./exports)" },
       { flag: "--since <date>", desc: "Only export chats from this date onwards" },
       { flag: "--include-metadata", desc: "Include metadata headers in exports" },
       { flag: "--all-profiles, -a", desc: "Export conversations from all profiles" },

package/src/cli/commands/export-command.ts

@@ -16,14 +16,14 @@ import { writeTextFile } from "../../infrastructure/io.ts";
 
 interface ExportCommandOptions {
   help: boolean;
-  output: string;
+  out: string;
   format: "markdown" | "json";
   includeMetadata: boolean;
 }
 
 const DEFAULT_OPTIONS: ExportCommandOptions = {
   help: false,
-  output: "",
+  out: "",
   format: "markdown",
   includeMetadata: false,
 };
@@ -67,7 +67,7 @@ export class ExportCommand implements CliCommand {
         payload: query,
       } as Query<FetchChatQueryPayload>);
 
-      const outputPath = options.output || this.defaultFilename(conversationId, options.format);
+      const outputPath = options.out || this.defaultFilename(conversationId, options.format);
 
       const content =
         options.format === "json"
@@ -108,9 +108,9 @@ export class ExportCommand implements CliCommand {
         case "-h":
           options.help = true;
           break;
-        case "--output":
+        case "--out":
         case "-o":
-          options.output = args[++i] ?? "";
+          options.out = args[++i] ?? "";
           break;
         case "--format":
         case "-f":
@@ -141,7 +141,7 @@ export class ExportCommand implements CliCommand {
     console.log(chalk.bold("Options:"));
 
     const flags = [
-      { flag: "--output, -o <path>", desc: "Output file path (default: gemini-chat-<id>-<date>.md)" },
+      { flag: "--out, -o <path>", desc: "Output file path (default: gemini-chat-<id>-<date>.md)" },
       { flag: "--format, -f <fmt>", desc: "Output format: markdown, json (default: markdown)" },
       { flag: "--include-metadata", desc: "Include metadata header (ID, count, date)" },
       { flag: "--help, -h", desc: "Show this help message" },

package/src/cli/commands/fetch-command.ts

@@ -13,13 +13,13 @@ import { writeTextFile } from "../../infrastructure/io.ts";
 interface FetchCommandOptions {
   help: boolean;
   format: "text" | "json";
-  path: string;
+  out: string;
 }
 
 const DEFAULT_OPTIONS: FetchCommandOptions = {
   help: false,
   format: "text",
-  path: "",
+  out: "",
 };
 
 export class FetchCommand implements CliCommand {
@@ -52,9 +52,9 @@ export class FetchCommand implements CliCommand {
     } as Query<FetchChatQueryPayload>);
 
     if (options.format === "json") {
-      this.outputJson(result.messages, conversationId, options.path);
+      this.outputJson(result.messages, conversationId, options.out);
     } else {
-      this.outputText(result.messages, conversationId, options.path);
+      this.outputText(result.messages, conversationId, options.out);
     }
   }
 
@@ -81,16 +81,16 @@ export class FetchCommand implements CliCommand {
     }
   }
 
-  private outputJson(messages: Message[], conversationId: string, path: string): void {
+  private outputJson(messages: Message[], conversationId: string, out: string): void {
     const output = JSON.stringify({ conversationId, messages }, null, 2);
-    if (path) {
-      this.writeOutput(path, output);
+    if (out) {
+      this.writeOutput(out, output);
     } else {
       console.log(output);
     }
   }
 
-  private outputText(messages: Message[], conversationId: string, path: string): void {
+  private outputText(messages: Message[], conversationId: string, out: string): void {
     const lines: string[] = [];
 
     lines.push(chalk.bold(`Conversation: ${chalk.cyan(conversationId)}`));
@@ -109,16 +109,16 @@ export class FetchCommand implements CliCommand {
     }
 
     const output = lines.join("\n");
-    if (path) {
-      this.writeOutput(path, output);
+    if (out) {
+      this.writeOutput(out, output);
     } else {
       console.log(output);
     }
   }
 
-  private writeOutput(path: string, content: string): void {
-    writeTextFile(path, content);
-    console.log(chalk.dim(`Output written to: ${path}`));
+  private writeOutput(out: string, content: string): void {
+    writeTextFile(out, content);
+    console.log(chalk.dim(`Output written to: ${out}`));
   }
 
   private parseArgs(args: string[]): FetchCommandOptions {
@@ -135,9 +135,9 @@ export class FetchCommand implements CliCommand {
         case "-f":
           options.format = this.parseFormat(args[++i]);
           break;
-        case "--path":
-        case "-p":
-          options.path = args[++i] ?? "";
+        case "--out":
+        case "-o":
+          options.out = args[++i] ?? "";
           break;
       }
     }
@@ -160,7 +160,7 @@ export class FetchCommand implements CliCommand {
 
     const flags = [
       { flag: "--format, -f <fmt>", desc: "Output format: text, json (default: text)" },
-      { flag: "--path, -p <path>", desc: "Write output to file" },
+      { flag: "--out, -o <path>", desc: "Write output to file" },
       { flag: "--help, -h", desc: "Show this help message" },
     ];
 

package/src/cli/commands/list-command.ts

@@ -10,33 +10,37 @@ import {
 import { formatChatList } from "../../infrastructure/formatters.ts";
 import type { ChatInfo } from "../../core/types.ts";
 import { writeTextFile } from "../../infrastructure/io.ts";
+import { GemitermError } from "../../core/errors.ts";
+import { browser, select, type BrowserAction } from "../utils/prompts.ts";
 
 interface ListCommandOptions {
   help: boolean;
   limit: number;
   offset: number;
-  all: boolean;
   allProfiles: boolean;
+  profile: string;
   sort: "recent" | "oldest" | "alpha";
   search: string;
   after: string;
   before: string;
   format: "text" | "json";
-  path: string;
+  out: string;
+  interactive: boolean;
 }
 
 const DEFAULT_OPTIONS: ListCommandOptions = {
   help: false,
-  limit: 10,
+  limit: 0,
   offset: 0,
-  all: false,
   allProfiles: false,
+  profile: "",
   sort: "recent",
   search: "",
   after: "",
   before: "",
   format: "text",
-  path: "",
+  out: "",
+  interactive: false,
 };
 
 export class ListCommand implements CliCommand {
@@ -53,11 +57,13 @@ export class ListCommand implements CliCommand {
     }
 
     const mediator: Mediator = context.mediator;
+    const hasLimit = options.limit > 0;
     const query: ListChatsQueryPayload = {
-      limit: options.all ? undefined : options.limit,
+      limit: hasLimit ? options.limit : undefined,
       offset: options.offset || undefined,
       search: options.search || undefined,
       allProfiles: options.allProfiles,
+      profile: options.profile || undefined,
     };
 
     logger.debug(`Sending list-chats query: ${JSON.stringify(query)}`);
@@ -68,17 +74,24 @@ export class ListCommand implements CliCommand {
 
     let chats = result.chats;
 
+    if (options.interactive) {
+      await this.runInteractiveBrowser(chats, options, context);
+      return;
+    }
+
     chats = this.applySort(chats, options.sort);
     chats = this.applyDateFilter(chats, options.after, options.before);
 
-    if (!options.all) {
+    if (hasLimit) {
       chats = chats.slice(options.offset, options.offset + options.limit);
+    } else if (options.offset > 0) {
+      chats = chats.slice(options.offset);
     }
 
     if (options.format === "json") {
-      this.outputJson(chats, options.path);
+      this.outputJson(chats, options.out);
     } else {
-      this.outputText(chats, options.path, options.allProfiles);
+      this.outputText(chats, options.out, options.allProfiles || Boolean(options.profile));
     }
   }
 
@@ -115,27 +128,84 @@ export class ListCommand implements CliCommand {
     });
   }
 
-  private outputJson(chats: ChatInfo[], path: string): void {
+  private outputJson(chats: ChatInfo[], out: string): void {
     const output = JSON.stringify({ chats }, null, 2);
-    if (path) {
-      this.writeOutput(path, output);
+    if (out) {
+      this.writeOutput(out, output);
     } else {
       console.log(output);
     }
   }
 
-  private outputText(chats: ChatInfo[], path: string, allProfiles: boolean): void {
+  private outputText(chats: ChatInfo[], out: string, allProfiles: boolean): void {
     const output = formatChatList(chats, { includeProfileColumn: allProfiles });
-    if (path) {
-      this.writeOutput(path, output);
+    if (out) {
+      this.writeOutput(out, output);
     } else {
       console.log(output);
     }
   }
 
-  private writeOutput(path: string, content: string): void {
-    writeTextFile(path, content);
-    console.log(chalk.dim(`Output written to: ${path}`));
+  private writeOutput(out: string, content: string): void {
+    writeTextFile(out, content);
+    console.log(chalk.dim(`Output written to: ${out}`));
+  }
+
+  private async runInteractiveBrowser(
+    chats: ChatInfo[],
+    options: ListCommandOptions,
+    context: CliCommandContext,
+  ): Promise<void> {
+    while (true) {
+      const result = await browser({
+        chats,
+        initialSort: options.sort,
+      });
+      if (result.kind === "quit") return;
+      const actionResult = await this.showActionMenu(result.chat);
+      if (actionResult === "quit") return;
+      if (actionResult === "back") continue;
+      await this.executeAction(actionResult, result.chat, context);
+    }
+  }
+
+  private async showActionMenu(chat: ChatInfo): Promise<BrowserAction> {
+    const choice = await select<BrowserAction>({
+      message: `Selected: ${chat.id} — "${chat.title}"`,
+      choices: [
+        { value: "view", label: "View full conversation" },
+        { value: "export-markdown", label: "Export to Markdown" },
+        { value: "export-json", label: "Export to JSON" },
+        { value: "copy-id", label: "Copy conversation ID" },
+        { value: "back", label: "Back to list" },
+        { value: "quit", label: "Quit" },
+      ],
+    });
+    return choice;
+  }
+
+  private async executeAction(
+    action: "view" | "export-markdown" | "export-json" | "copy-id",
+    chat: ChatInfo,
+    context: CliCommandContext,
+  ): Promise<void> {
+    if (action === "copy-id") {
+      console.log(chalk.cyan(`Copied: ${chat.id}`));
+      return;
+    }
+    const { CommandRegistry } = await import("../command-registry.ts");
+    const registry = new CommandRegistry();
+    registry.registerAllCommands();
+    if (action === "view") {
+      const fetch = registry.getHandler("fetch");
+      if (fetch) await fetch.execute([chat.id, "--format", "text"], context);
+    } else if (action === "export-markdown") {
+      const exportCmd = registry.getHandler("export");
+      if (exportCmd) await exportCmd.execute([chat.id, "--format", "markdown"], context);
+    } else if (action === "export-json") {
+      const exportCmd = registry.getHandler("export");
+      if (exportCmd) await exportCmd.execute([chat.id, "--format", "json"], context);
+    }
   }
 
   private parseArgs(args: string[]): ListCommandOptions {
@@ -155,12 +225,13 @@ export class ListCommand implements CliCommand {
         case "--offset":
           options.offset = parseInt(args[++i], 10) || 0;
           break;
-        case "--all":
-          options.all = true;
-          break;
         case "--all-profiles":
           options.allProfiles = true;
           break;
+        case "--profile":
+        case "-p":
+          options.profile = args[++i] ?? "";
+          break;
         case "--sort":
           options.sort = this.parseSort(args[++i]);
           break;
@@ -178,13 +249,28 @@ export class ListCommand implements CliCommand {
         case "-f":
           options.format = this.parseFormat(args[++i]);
           break;
-        case "--path":
-        case "-p":
-          options.path = args[++i] ?? "";
+        case "--out":
+        case "-o":
+          options.out = args[++i] ?? "";
+          break;
+        case "--interactive":
+        case "-i":
+          options.interactive = true;
           break;
       }
     }
 
+    if (options.interactive && !options.profile) {
+      options.allProfiles = true;
+    }
+
+    if (
+      options.interactive &&
+      (options.format !== DEFAULT_OPTIONS.format || options.out !== DEFAULT_OPTIONS.out)
+    ) {
+      throw new GemitermError("Cannot use --interactive with --format or --out.");
+    }
+
     return options;
   }
 
@@ -204,16 +290,17 @@ export class ListCommand implements CliCommand {
     console.log(chalk.bold("Options:"));
 
     const flags = [
-      { flag: "--limit, -n N", desc: "Number of results (default: 10)" },
+      { flag: "--limit, -n N", desc: "Limit number of results (no limit by default)" },
       { flag: "--offset N", desc: "Skip N results (default: 0)" },
-      { flag: "--all", desc: "Show all conversations (no limit)" },
       { flag: "--all-profiles", desc: "Show conversations from all profiles (with Profile column in text output)" },
+      { flag: "--profile, -p <name>", desc: "Filter conversations to a specific profile (non-interactive)" },
       { flag: "--sort <mode>", desc: "Sort order: recent, oldest, alpha (default: recent)" },
       { flag: "--search, -s <query>", desc: "Filter by title search" },
       { flag: "--after <date>", desc: "Only show chats after this date" },
       { flag: "--before <date>", desc: "Only show chats before this date" },
       { flag: "--format, -f <fmt>", desc: "Output format: text, json (default: text)" },
-      { flag: "--path, -p <path>", desc: "Write output to file" },
+      { flag: "--out, -o <path>", desc: "Write output to file" },
+      { flag: "--interactive, -i", desc: "Open interactive chat-list browser (TTY only; shows all profiles by default)" },
       { flag: "--help, -h", desc: "Show this help message" },
     ];
 

package/src/cli/commands/profile-command.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
-import { createInterface } from "node:readline";
 import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { text } from "../utils/prompts.ts";
 import { Logger } from "../../infrastructure/logger.ts";
 import { CookieStorage, ProfileManager } from "../../infrastructure/storage.ts";
 import { PlaywrightCliDriver } from "../../services/playwright-cli-driver.ts";
@@ -215,12 +215,6 @@ export class ProfileCommand implements CliCommand {
   }
 
   private promptInput(prompt: string): Promise<string> {
-    return new Promise<string>((resolve) => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      rl.question(`${chalk.cyan(prompt + ": ")} `, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    });
+    return text({ message: prompt });
   }
 }

package/src/cli/utils/interactive-prompt.ts

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { createInterface } from "node:readline";
+import { CancellationError, text, type TextOptions } from "./prompts.ts";
 
 export interface MessageHandlerResult {
   response: string;
@@ -11,54 +11,62 @@ export interface InteractiveLoopOptions {
   profileName?: string | null;
 }
 
+export interface InteractiveLoopDeps {
+  text: (opts: TextOptions) => Promise<string>;
+  CancellationError: typeof CancellationError;
+}
+
 export async function runInteractiveLoop(
   messageHandler: MessageHandler,
   options: InteractiveLoopOptions = {},
+  deps: InteractiveLoopDeps = { text, CancellationError },
 ): Promise<void> {
   const profileLabel = options.profileName ?? "default";
   console.log(chalk.dim(`Starting chat session (profile: ${chalk.cyan(profileLabel)})`));
   console.log(chalk.dim("Type your message and press Enter. Type /exit to quit.\n"));
 
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
+  let resolveOuter: () => void = () => {};
+  const outerPromise = new Promise<void>((resolve) => {
+    resolveOuter = resolve;
   });
 
-  const prompt = (): void => {
-    rl.question(chalk.green.bold("You: "), async (input) => {
-      const trimmed = input.trim();
-
-      if (trimmed === "/exit" || trimmed === "/quit") {
-        rl.close();
+  const prompt = async (): Promise<void> => {
+    let input: string;
+    try {
+      input = await deps.text({ message: "You" });
+    } catch (error) {
+      if (error instanceof deps.CancellationError) {
+        console.log(chalk.dim("\nGoodbye."));
+        resolveOuter();
         return;
       }
-
-      if (!trimmed) {
-        prompt();
-        return;
-      }
-
-      try {
-        const result = await messageHandler(trimmed);
-        console.log(chalk.blue.bold("Model:"));
-        console.log(result.response);
-        console.log("");
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red(`Error: ${message}`));
-        console.log("");
-      }
-
-      prompt();
-    });
+      throw error;
+    }
+    const trimmed = input.trim();
+    if (trimmed === "/exit" || trimmed === "/quit") {
+      console.log(chalk.dim("\nGoodbye."));
+      resolveOuter();
+      return;
+    }
+    if (!trimmed) {
+      await prompt();
+      return;
+    }
+    try {
+      console.log(chalk.dim("Thinking…"));
+      const result = await messageHandler(trimmed);
+      console.log(chalk.blue.bold("Model:"));
+      console.log(result.response);
+      console.log("");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Error: ${message}`));
+      console.log("");
+    }
+    await prompt();
   };
 
   prompt();
 
-  await new Promise<void>((resolve) => {
-    rl.on("close", () => {
-      console.log(chalk.dim("\nGoodbye."));
-      resolve();
-    });
-  });
-}
+  await outerPromise;
+}