gemiterm 2.0.0

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

@@ -0,0 +1,243 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Query } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import type { ChatInfo } from "../../core/types.ts";
+import {
+  QUERY_TYPES,
+  type ListChatsQueryPayload,
+  type ListChatsQueryResult,
+  type FetchChatQueryPayload,
+  type FetchChatQueryResult,
+} from "../../core/query-handlers.ts";
+import { formatChatAsMarkdown } from "../../infrastructure/formatters.ts";
+import { ensureDir, writeTextFile } from "../../infrastructure/io.ts";
+import { joinPath, resolvePath } from "../../infrastructure/path-utils.ts";
+
+interface ExportAllCommandOptions {
+  help: boolean;
+  outputDir: string;
+  since: string;
+  includeMetadata: boolean;
+  allProfiles: boolean;
+}
+
+const DEFAULT_OPTIONS: ExportAllCommandOptions = {
+  help: false,
+  outputDir: "./exports",
+  since: "",
+  includeMetadata: false,
+  allProfiles: false,
+};
+
+interface ExportResult {
+  id: string;
+  title: string;
+  filePath: string;
+  success: boolean;
+  error?: string;
+}
+
+export class ExportAllCommand implements CliCommand {
+  readonly name = "export-all";
+  readonly description = "Export all conversations to files";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("export-all-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    const mediator: Mediator = context.mediator;
+
+    logger.debug("Sending list-chats query for export-all");
+
+    try {
+      const listResult = await mediator.send<ListChatsQueryResult>({
+        type: QUERY_TYPES.LIST_CHATS,
+        payload: {
+          allProfiles: options.allProfiles,
+        } as ListChatsQueryPayload,
+      } as Query<ListChatsQueryPayload>);
+
+      let chats = listResult.chats;
+
+      chats = this.applyDateFilter(chats, options.since);
+
+      if (chats.length === 0) {
+        console.log(chalk.dim("No conversations found to export."));
+        return;
+      }
+
+      console.log(chalk.bold(`Found ${chats.length} conversation${chats.length !== 1 ? "s" : ""} to export.`));
+      console.log("");
+
+      const outputDir = resolvePath(options.outputDir);
+      ensureDir(outputDir);
+
+      const results: ExportResult[] = [];
+
+      for (let i = 0; i < chats.length; i++) {
+        const chat = chats[i];
+        const progress = `[${i + 1}/${chats.length}]`;
+        process.stdout.write(`  ${chalk.dim(progress)} Exporting ${chalk.cyan(chat.id)}...`);
+
+        try {
+          const fetchResult = await mediator.send<FetchChatQueryResult>({
+            type: QUERY_TYPES.FETCH_CHAT,
+            payload: { conversationId: chat.id } as FetchChatQueryPayload,
+          } as Query<FetchChatQueryPayload>);
+
+          const filename = this.sanitizeFilename(chat.title || chat.id);
+          const filePath = joinPath(outputDir, `${filename}.md`);
+          const content = formatChatAsMarkdown(
+            fetchResult.messages,
+            chat.title,
+            chat.id,
+            options.includeMetadata,
+          );
+
+          writeTextFile(filePath, content);
+
+          results.push({ id: chat.id, title: chat.title, filePath, success: true });
+          process.stdout.write(chalk.green(" OK\n"));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          results.push({ id: chat.id, title: chat.title, filePath: "", success: false, error: message });
+          process.stdout.write(chalk.red(" FAILED\n"));
+          logger.warn(`Failed to export ${chat.id}: ${message}`);
+        }
+      }
+
+      this.writeIndex(outputDir, results, options.includeMetadata);
+      this.printSummary(results, outputDir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  }
+
+  private applyDateFilter(chats: ChatInfo[], since: string): ChatInfo[] {
+    if (!since) return chats;
+    const sinceDate = new Date(since);
+    if (isNaN(sinceDate.getTime())) return chats;
+    return chats.filter((chat) => new Date(chat.timestamp) >= sinceDate);
+  }
+
+  private sanitizeFilename(title: string): string {
+    const date = new Date().toISOString().slice(0, 10);
+    const safe = title
+      .replace(/[/\\?%*:|"<>]/g, "-")
+      .replace(/\s+/g, "-")
+      .replace(/-+/g, "-")
+      .slice(0, 60);
+    return `gemini-chat-${safe}-${date}`.replace(/-+$/, "");
+  }
+
+  private writeIndex(outputDir: string, results: ExportResult[], includeMetadata: boolean): void {
+    const lines: string[] = [];
+
+    lines.push("# Exported Conversations");
+    lines.push("");
+    lines.push(`> Total: ${results.length}`);
+    lines.push(`> Exported: ${new Date().toISOString()}`);
+    lines.push("");
+
+    if (includeMetadata) {
+      const succeeded = results.filter((r) => r.success).length;
+      const failed = results.filter((r) => !r.success).length;
+      lines.push(`> Successful: ${succeeded} | Failed: ${failed}`);
+      lines.push("");
+    }
+
+    lines.push("## Conversations");
+    lines.push("");
+
+    const succeeded = results.filter((r) => r.success);
+    for (const result of succeeded) {
+      const filename = result.filePath.split(/[\\/]/).pop() || result.filePath;
+      lines.push(`- [${result.title || result.id}](${filename})`);
+    }
+
+    const failed = results.filter((r) => !r.success);
+    if (failed.length > 0) {
+      lines.push("");
+      lines.push("## Failed Exports");
+      lines.push("");
+      for (const result of failed) {
+        lines.push(`- **${result.title || result.id}**: ${result.error || "Unknown error"}`);
+      }
+    }
+
+    const indexPath = joinPath(outputDir, "index.md");
+    writeTextFile(indexPath, lines.join("\n"));
+  }
+
+  private printSummary(results: ExportResult[], outputDir: string): void {
+    const succeeded = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+
+    console.log("");
+    console.log(chalk.bold("Export Summary:"));
+    console.log(`  Exported: ${chalk.green(succeeded.length)}`);
+    if (failed.length > 0) {
+      console.log(`  Failed:  ${chalk.red(failed.length)}`);
+    }
+    console.log(`  Output:  ${outputDir}`);
+    console.log(`  Index:   ${chalk.cyan(joinPath(outputDir, "index.md"))}`);
+  }
+
+  private parseArgs(args: string[]): ExportAllCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--help":
+        case "-h":
+          options.help = true;
+          break;
+        case "--output-dir":
+        case "-o":
+          options.outputDir = args[++i] ?? DEFAULT_OPTIONS.outputDir;
+          break;
+        case "--since":
+          options.since = args[++i] ?? "";
+          break;
+        case "--include-metadata":
+          options.includeMetadata = true;
+          break;
+        case "--all-profiles":
+        case "-a":
+          options.allProfiles = true;
+          break;
+      }
+    }
+
+    return options;
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm export-all [options]"));
+    console.log("");
+    console.log(chalk.bold("Options:"));
+
+    const flags = [
+      { flag: "--output-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" },
+      { flag: "--help, -h", desc: "Show this help message" },
+    ];
+
+    const maxLen = Math.max(...flags.map((f) => f.flag.length));
+    for (const f of flags) {
+      const padded = f.flag.padEnd(maxLen + 2);
+      console.log(`  ${chalk.cyan(padded)}${chalk.dim(f.desc)}`);
+    }
+  }
+}

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

@@ -0,0 +1,156 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Query } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import {
+  QUERY_TYPES,
+  type FetchChatQueryPayload,
+  type FetchChatQueryResult,
+} from "../../core/query-handlers.ts";
+import {
+  formatChatAsMarkdown,
+  formatChatAsJson,
+} from "../../infrastructure/formatters.ts";
+import { validateConversationId } from "../../infrastructure/validators.ts";
+import { writeTextFile } from "../../infrastructure/io.ts";
+
+interface ExportCommandOptions {
+  help: boolean;
+  output: string;
+  format: "markdown" | "json";
+  includeMetadata: boolean;
+}
+
+const DEFAULT_OPTIONS: ExportCommandOptions = {
+  help: false,
+  output: "",
+  format: "markdown",
+  includeMetadata: false,
+};
+
+export class ExportCommand implements CliCommand {
+  readonly name = "export";
+  readonly description = "Export a conversation to a file";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("export-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    const conversationId = this.extractConversationId(args);
+
+    if (!conversationId) {
+      console.error(chalk.red("Error: conversation ID is required."));
+      this.showUsage();
+      process.exit(1);
+    }
+
+    try {
+      validateConversationId(conversationId);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${(error as Error).message}`));
+      process.exit(1);
+    }
+
+    const mediator: Mediator = context.mediator;
+    const query: FetchChatQueryPayload = { conversationId };
+
+    logger.debug(`Sending fetch-chat query for export: ${JSON.stringify(query)}`);
+
+    try {
+      const result = await mediator.send<FetchChatQueryResult>({
+        type: QUERY_TYPES.FETCH_CHAT,
+        payload: query,
+      } as Query<FetchChatQueryPayload>);
+
+      const outputPath = options.output || this.defaultFilename(conversationId, options.format);
+
+      const content =
+        options.format === "json"
+          ? formatChatAsJson(result.messages, conversationId)
+          : formatChatAsMarkdown(result.messages, conversationId, conversationId, options.includeMetadata);
+
+      writeTextFile(outputPath, content);
+      console.log(chalk.green(`Exported conversation '${chalk.cyan(conversationId)}' to: ${outputPath}`));
+      logger.info(`Exported conversation ${conversationId} to ${outputPath}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  }
+
+  private extractConversationId(args: string[]): string | null {
+    for (const arg of args) {
+      if (arg.startsWith("--") || arg.startsWith("-")) continue;
+      return arg;
+    }
+    return null;
+  }
+
+  private defaultFilename(conversationId: string, format: "markdown" | "json"): string {
+    const date = new Date().toISOString().slice(0, 10);
+    const ext = format === "json" ? "json" : "md";
+    return `gemini-chat-${conversationId}-${date}.${ext}`;
+  }
+
+  private parseArgs(args: string[]): ExportCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--help":
+        case "-h":
+          options.help = true;
+          break;
+        case "--output":
+        case "-o":
+          options.output = args[++i] ?? "";
+          break;
+        case "--format":
+        case "-f":
+          options.format = this.parseFormat(args[++i]);
+          break;
+        case "--include-metadata":
+          options.includeMetadata = true;
+          break;
+      }
+    }
+
+    return options;
+  }
+
+  private parseFormat(value: string | undefined): "markdown" | "json" {
+    if (value === "markdown" || value === "json") return value;
+    return DEFAULT_OPTIONS.format;
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm export <conversation_id> [options]"));
+    console.log("");
+    console.log(chalk.bold("Arguments:"));
+    console.log(
+      `  ${chalk.cyan("conversation_id".padEnd(20))}${chalk.dim("ID of the conversation to export")}`,
+    );
+    console.log("");
+    console.log(chalk.bold("Options:"));
+
+    const flags = [
+      { flag: "--output, -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" },
+    ];
+
+    const maxLen = Math.max(...flags.map((f) => f.flag.length));
+    for (const f of flags) {
+      const padded = f.flag.padEnd(maxLen + 2);
+      console.log(`  ${chalk.cyan(padded)}${chalk.dim(f.desc)}`);
+    }
+  }
+}

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

@@ -0,0 +1,176 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Query } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import {
+  QUERY_TYPES,
+  type FetchChatQueryPayload,
+  type FetchChatQueryResult,
+} from "../../core/query-handlers.ts";
+import type { Message } from "../../core/types.ts";
+import { writeTextFile } from "../../infrastructure/io.ts";
+
+interface FetchCommandOptions {
+  help: boolean;
+  format: "text" | "json";
+  path: string;
+}
+
+const DEFAULT_OPTIONS: FetchCommandOptions = {
+  help: false,
+  format: "text",
+  path: "",
+};
+
+export class FetchCommand implements CliCommand {
+  readonly name = "fetch";
+  readonly description = "Fetch and display a conversation";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("fetch-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    let conversationId = this.extractConversationId(args, options);
+
+    if (!conversationId) {
+      await this.invokeListCommand(context);
+      return;
+    }
+
+    const mediator: Mediator = context.mediator;
+    const query: FetchChatQueryPayload = { conversationId };
+
+    logger.debug(`Sending fetch-chat query: ${JSON.stringify(query)}`);
+    const result = await mediator.send<FetchChatQueryResult>({
+      type: QUERY_TYPES.FETCH_CHAT,
+      payload: query,
+    } as Query<FetchChatQueryPayload>);
+
+    if (options.format === "json") {
+      this.outputJson(result.messages, conversationId, options.path);
+    } else {
+      this.outputText(result.messages, conversationId, options.path);
+    }
+  }
+
+  private extractConversationId(args: string[], options: FetchCommandOptions): string | null {
+    for (const arg of args) {
+      if (arg.startsWith("--") || arg.startsWith("-")) continue;
+      return arg;
+    }
+    return null;
+  }
+
+  private async invokeListCommand(context: CliCommandContext): Promise<void> {
+    const { CommandRegistry } = await import("../command-registry.ts");
+    const registry = new CommandRegistry();
+    registry.registerAllCommands();
+
+    const listHandler = registry.getHandler("list");
+    if (listHandler) {
+      console.log(chalk.dim("No conversation ID specified. Listing conversations:\n"));
+      await listHandler.execute([], context);
+    } else {
+      console.error("Could not invoke list command.");
+      process.exit(1);
+    }
+  }
+
+  private outputJson(messages: Message[], conversationId: string, path: string): void {
+    const output = JSON.stringify({ conversationId, messages }, null, 2);
+    if (path) {
+      this.writeOutput(path, output);
+    } else {
+      console.log(output);
+    }
+  }
+
+  private outputText(messages: Message[], conversationId: string, path: string): void {
+    const lines: string[] = [];
+
+    lines.push(chalk.bold(`Conversation: ${chalk.cyan(conversationId)}`));
+    lines.push("");
+
+    if (messages.length === 0) {
+      lines.push(chalk.dim("No messages found."));
+    } else {
+      for (const msg of messages) {
+        const label =
+          msg.role === "user" ? chalk.green.bold("User:") : chalk.blue.bold("Model:");
+        lines.push(label);
+        lines.push(msg.content);
+        lines.push("");
+      }
+    }
+
+    const output = lines.join("\n");
+    if (path) {
+      this.writeOutput(path, output);
+    } else {
+      console.log(output);
+    }
+  }
+
+  private writeOutput(path: string, content: string): void {
+    writeTextFile(path, content);
+    console.log(chalk.dim(`Output written to: ${path}`));
+  }
+
+  private parseArgs(args: string[]): FetchCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      switch (arg) {
+        case "--help":
+        case "-h":
+          options.help = true;
+          break;
+        case "--format":
+        case "-f":
+          options.format = this.parseFormat(args[++i]);
+          break;
+        case "--path":
+        case "-p":
+          options.path = args[++i] ?? "";
+          break;
+      }
+    }
+
+    return options;
+  }
+
+  private parseFormat(value: string | undefined): "text" | "json" {
+    if (value === "text" || value === "json") return value;
+    return DEFAULT_OPTIONS.format;
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm fetch [conversation_id] [options]"));
+    console.log("");
+    console.log(chalk.bold("Arguments:"));
+    console.log(`  ${chalk.cyan("conversation_id".padEnd(20))}${chalk.dim("ID of the conversation to fetch (optional)")}`);
+    console.log("");
+    console.log(chalk.bold("Options:"));
+
+    const flags = [
+      { flag: "--format, -f <fmt>", desc: "Output format: text, json (default: text)" },
+      { flag: "--path, -p <path>", desc: "Write output to file" },
+      { flag: "--help, -h", desc: "Show this help message" },
+    ];
+
+    const maxLen = Math.max(...flags.map((f) => f.flag.length));
+    for (const f of flags) {
+      const padded = f.flag.padEnd(maxLen + 2);
+      console.log(`  ${chalk.cyan(padded)}${chalk.dim(f.desc)}`);
+    }
+
+    console.log("");
+    console.log(chalk.dim("If no conversation_id is provided, the list command will be invoked."));
+  }
+}

package/src/cli/commands/help.ts

@@ -0,0 +1,45 @@
+import chalk from "chalk";
+import type { CommandRegistry } from "../command-registry.ts";
+
+const GLOBAL_OPTIONS = [
+  { flag: "--version", description: "Show version number" },
+  { flag: "--help, -h", description: "Show this help message" },
+  { flag: "--verbose, -v", description: "Enable verbose output (also: GEMITERM_VERBOSE=true)" },
+];
+
+export function showHelp(registry?: CommandRegistry): void {
+  const lines: string[] = [];
+
+  lines.push(chalk.bold.white("GemiTerm") + chalk.dim(" - Google Gemini Terminal Client"));
+  lines.push("");
+  lines.push(chalk.bold("Usage:"));
+  lines.push("  gemiterm [command] [options]");
+  lines.push("");
+  lines.push(chalk.bold("Commands:"));
+
+  if (registry) {
+    const names = registry.getRegisteredNames();
+    const maxCmdLen = Math.max(...names.map((n) => n.length));
+    for (const name of names) {
+      const handler = registry.getHandler(name);
+      if (handler) {
+        const padded = name.padEnd(maxCmdLen + 2);
+        lines.push(`  ${chalk.green(padded)}${chalk.dim(handler.description)}`);
+      }
+    }
+  }
+
+  lines.push("");
+  lines.push(chalk.bold("Global Options:"));
+
+  const maxOptLen = Math.max(...GLOBAL_OPTIONS.map((o) => o.flag.length));
+  for (const opt of GLOBAL_OPTIONS) {
+    const padded = opt.flag.padEnd(maxOptLen + 2);
+    lines.push(`  ${chalk.cyan(padded)}${chalk.dim(opt.description)}`);
+  }
+
+  lines.push("");
+  lines.push(chalk.dim("Run 'gemiterm <command> --help' for more information about a command."));
+
+  console.log(lines.join("\n"));
+}

package/src/cli/commands/install-browser-command.ts

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { InstallBrowserService, InstallBrowserError } from "../../services/install-browser-service.ts";
+
+export class InstallBrowserCommand implements CliCommand {
+  readonly name = "install-browser";
+  readonly description = "Install Chromium browser for Playwright (hidden command)";
+
+  async execute(_args: string[], _context: CliCommandContext): Promise<void> {
+    const logger = new Logger("install-browser-command");
+    logger.debug("Executing install-browser command");
+    const service = new InstallBrowserService(logger);
+
+    console.log(chalk.dim("Checking browser installation..."));
+
+    try {
+      await service.install();
+      console.log(chalk.green("Browser ready."));
+    } catch (error) {
+      if (error instanceof InstallBrowserError) {
+        logger.error(error.message);
+        if (error.cause) {
+          logger.error(`Cause: ${error.cause.message}`);
+        }
+        console.error(chalk.red("Failed to install browser."));
+        console.error(chalk.dim("You may need to run: bunx @playwright/cli install chromium"));
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+}