gemiterm 2.0.0

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

@@ -0,0 +1,226 @@
+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 ListChatsQueryPayload,
+  type ListChatsQueryResult,
+} from "../../core/query-handlers.ts";
+import { formatChatList } from "../../infrastructure/formatters.ts";
+import type { ChatInfo } from "../../core/types.ts";
+import { writeTextFile } from "../../infrastructure/io.ts";
+
+interface ListCommandOptions {
+  help: boolean;
+  limit: number;
+  offset: number;
+  all: boolean;
+  allProfiles: boolean;
+  sort: "recent" | "oldest" | "alpha";
+  search: string;
+  after: string;
+  before: string;
+  format: "text" | "json";
+  path: string;
+}
+
+const DEFAULT_OPTIONS: ListCommandOptions = {
+  help: false,
+  limit: 10,
+  offset: 0,
+  all: false,
+  allProfiles: false,
+  sort: "recent",
+  search: "",
+  after: "",
+  before: "",
+  format: "text",
+  path: "",
+};
+
+export class ListCommand implements CliCommand {
+  readonly name = "list";
+  readonly description = "List conversations";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("list-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    const mediator: Mediator = context.mediator;
+    const query: ListChatsQueryPayload = {
+      limit: options.all ? undefined : options.limit,
+      offset: options.offset || undefined,
+      search: options.search || undefined,
+      allProfiles: options.allProfiles,
+    };
+
+    logger.debug(`Sending list-chats query: ${JSON.stringify(query)}`);
+    const result = await mediator.send<ListChatsQueryResult>({
+      type: QUERY_TYPES.LIST_CHATS,
+      payload: query,
+    } as Query<ListChatsQueryPayload>);
+
+    let chats = result.chats;
+
+    chats = this.applySort(chats, options.sort);
+    chats = this.applyDateFilter(chats, options.after, options.before);
+
+    if (!options.all) {
+      chats = chats.slice(options.offset, options.offset + options.limit);
+    }
+
+    if (options.format === "json") {
+      this.outputJson(chats, options.path);
+    } else {
+      this.outputText(chats, options.path, options.allProfiles);
+    }
+  }
+
+  private applySort(chats: ChatInfo[], sort: "recent" | "oldest" | "alpha"): ChatInfo[] {
+    const sorted = [...chats];
+    switch (sort) {
+      case "recent":
+        sorted.sort((a, b) => b.timestamp - a.timestamp);
+        break;
+      case "oldest":
+        sorted.sort((a, b) => a.timestamp - b.timestamp);
+        break;
+      case "alpha":
+        sorted.sort((a, b) => a.title.localeCompare(b.title));
+        break;
+    }
+    return sorted;
+  }
+
+  private applyDateFilter(chats: ChatInfo[], after: string, before: string): ChatInfo[] {
+    return chats.filter((chat) => {
+      const chatDate = new Date(chat.timestamp);
+      if (after) {
+        const afterDate = new Date(after);
+        if (isNaN(afterDate.getTime())) return true;
+        if (chatDate < afterDate) return false;
+      }
+      if (before) {
+        const beforeDate = new Date(before);
+        if (isNaN(beforeDate.getTime())) return true;
+        if (chatDate > beforeDate) return false;
+      }
+      return true;
+    });
+  }
+
+  private outputJson(chats: ChatInfo[], path: string): void {
+    const output = JSON.stringify({ chats }, null, 2);
+    if (path) {
+      this.writeOutput(path, output);
+    } else {
+      console.log(output);
+    }
+  }
+
+  private outputText(chats: ChatInfo[], path: string, allProfiles: boolean): void {
+    const output = formatChatList(chats, { includeProfileColumn: allProfiles });
+    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[]): ListCommandOptions {
+    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 "--limit":
+        case "-n":
+          options.limit = parseInt(args[++i], 10) || DEFAULT_OPTIONS.limit;
+          break;
+        case "--offset":
+          options.offset = parseInt(args[++i], 10) || 0;
+          break;
+        case "--all":
+          options.all = true;
+          break;
+        case "--all-profiles":
+          options.allProfiles = true;
+          break;
+        case "--sort":
+          options.sort = this.parseSort(args[++i]);
+          break;
+        case "--search":
+        case "-s":
+          options.search = args[++i] ?? "";
+          break;
+        case "--after":
+          options.after = args[++i] ?? "";
+          break;
+        case "--before":
+          options.before = args[++i] ?? "";
+          break;
+        case "--format":
+        case "-f":
+          options.format = this.parseFormat(args[++i]);
+          break;
+        case "--path":
+        case "-p":
+          options.path = args[++i] ?? "";
+          break;
+      }
+    }
+
+    return options;
+  }
+
+  private parseSort(value: string | undefined): "recent" | "oldest" | "alpha" {
+    if (value === "recent" || value === "oldest" || value === "alpha") return value;
+    return DEFAULT_OPTIONS.sort;
+  }
+
+  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 list [options]"));
+    console.log("");
+    console.log(chalk.bold("Options:"));
+
+    const flags = [
+      { flag: "--limit, -n N", desc: "Number of results (default: 10)" },
+      { 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: "--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: "--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/new-command.ts

@@ -0,0 +1,147 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import type { Mediator, Command } from "../../core/mediator.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import {
+  COMMAND_TYPES,
+  type StartNewChatCommandPayload,
+  type StartNewChatCommandResult,
+} from "../../core/command-handlers.ts";
+import { runInteractiveLoop, type MessageHandlerResult } from "../utils/interactive-prompt.ts";
+
+interface NewCommandOptions {
+  help: boolean;
+  profile: string | null;
+}
+
+const DEFAULT_OPTIONS: NewCommandOptions = {
+  help: false,
+  profile: null,
+};
+
+export class NewCommand implements CliCommand {
+  readonly name = "new";
+  readonly description = "Start a new conversation";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("new-command");
+    const options = this.parseArgs(args);
+
+    if (options.help) {
+      this.showUsage();
+      return;
+    }
+
+    let message: string | null = null;
+
+    for (const arg of args) {
+      if (arg.startsWith("--") || arg.startsWith("-")) continue;
+      if (options.profile && arg === options.profile) continue;
+      if (!message) {
+        message = arg;
+      }
+    }
+
+    const mediator: Mediator = context.mediator;
+
+    if (message) {
+      await this.sendNonInteractive(mediator, message, options.profile, logger);
+    } else {
+      await this.startInteractive(mediator, options.profile, logger);
+    }
+  }
+
+  private async sendNonInteractive(
+    mediator: Mediator,
+    message: string,
+    profileName: string | null,
+    logger: Logger,
+  ): Promise<void> {
+    logger.debug("Starting new chat with message");
+    const payload: StartNewChatCommandPayload = { message };
+    if (profileName) {
+      payload.profileName = profileName;
+    }
+
+    const result = await mediator.send<StartNewChatCommandResult>({
+      type: COMMAND_TYPES.START_NEW_CHAT,
+      payload,
+    } as Command<StartNewChatCommandPayload>);
+
+    console.log(chalk.cyan(`Conversation ID: ${result.conversationId}`));
+    console.log(chalk.blue.bold("Model:"));
+    console.log(result.response);
+  }
+
+  private async startInteractive(
+    mediator: Mediator,
+    profileName: string | null,
+    logger: Logger,
+  ): Promise<void> {
+    let conversationId: string | null = null;
+
+    const messageHandler = async (message: string): Promise<MessageHandlerResult> => {
+      const payload: StartNewChatCommandPayload = { message };
+      if (profileName) {
+        payload.profileName = profileName;
+      }
+
+      const result = await mediator.send<StartNewChatCommandResult>({
+        type: COMMAND_TYPES.START_NEW_CHAT,
+        payload,
+      } as Command<StartNewChatCommandPayload>);
+
+      const isFirst = !conversationId;
+      if (isFirst) {
+        conversationId = result.conversationId;
+        console.log(chalk.dim(`Conversation started: ${chalk.cyan(conversationId)}`));
+      } else {
+        console.log(chalk.dim(`Response from: ${chalk.cyan(result.conversationId)}`));
+      }
+
+      return { response: result.response };
+    };
+
+    await runInteractiveLoop(messageHandler, { profileName });
+  }
+
+  private parseArgs(args: string[]): NewCommandOptions {
+    const options = { ...DEFAULT_OPTIONS };
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--help" || arg === "-h") {
+        options.help = true;
+      } else if (arg === "--profile" || arg === "-p") {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          options.profile = next;
+          i++;
+        } else {
+          console.error(chalk.red(`Error: --profile requires a profile name`));
+          process.exit(1);
+        }
+      }
+    }
+
+    return options;
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm new [message] [options]"));
+    console.log("");
+    console.log(chalk.bold("Arguments:"));
+    console.log(
+      `  ${chalk.cyan("message".padEnd(20))}${chalk.dim("Message to send (optional, starts interactive mode if omitted)")}`,
+    );
+    console.log("");
+    console.log(chalk.bold("Options:"));
+    console.log(
+      `  ${chalk.cyan("--profile, -p <name>".padEnd(22))}${chalk.dim("Use a specific profile (default profile used if omitted)")}`,
+    );
+    console.log(`  ${chalk.cyan("--help, -h".padEnd(22))}${chalk.dim("Show this help message")}`);
+    console.log("");
+    console.log(chalk.dim("If no message is provided, an interactive chat session will start."));
+    console.log(chalk.dim("In interactive mode, type /exit or /quit to exit."));
+  }
+}

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

@@ -0,0 +1,226 @@
+import chalk from "chalk";
+import { createInterface } from "node:readline";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { CookieStorage, ProfileManager } from "../../infrastructure/storage.ts";
+import { PlaywrightCliDriver } from "../../services/playwright-cli-driver.ts";
+import { CookieMonitor } from "../../services/cookie-monitor.ts";
+import { AuthService } from "../../services/auth-service.ts";
+import {
+  listProfiles,
+  getDefaultProfileName,
+  setDefaultProfileName,
+} from "../../infrastructure/config.ts";
+import { GemitermError } from "../../core/errors.ts";
+import { validateProfileName } from "../../infrastructure/validators.ts";
+import { formatProfileTable } from "../../infrastructure/formatters.ts";
+
+const ACTIONS = [
+  { name: "add", usage: "profile add <name>", desc: "Create new profile and authenticate" },
+  { name: "delete", usage: "profile delete <name>", desc: "Delete a profile" },
+  { name: "rename", usage: "profile rename <name> <newName>", desc: "Rename a profile" },
+  { name: "default", usage: "profile default <name>", desc: "Set default profile" },
+  { name: "list", usage: "profile list", desc: "List all profiles with status" },
+] as const;
+
+type ProfileAction = (typeof ACTIONS)[number]["name"];
+
+export class ProfileCommand implements CliCommand {
+  readonly name = "profile";
+  readonly description = "Manage authentication profiles";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("profile-command");
+    logger.debug("Executing profile command", args);
+
+    if (args.includes("--help") || args.includes("-h")) {
+      this.showUsage();
+      return;
+    }
+
+    const action = args[0] as ProfileAction | undefined;
+
+    if (!action) {
+      this.showUsage();
+      return;
+    }
+
+    const validActions = ACTIONS.map((a) => a.name);
+    if (!validActions.includes(action)) {
+      throw new GemitermError(
+        `Unknown action '${action}'. Valid actions: ${validActions.join(", ")}`,
+      );
+    }
+
+    logger.debug("Profile action:", action);
+
+    switch (action) {
+      case "add":
+        await this.addProfile(args.slice(1), logger);
+        break;
+      case "delete":
+        await this.deleteProfile(args.slice(1), logger);
+        break;
+      case "rename":
+        await this.renameProfile(args.slice(1), logger);
+        break;
+      case "default":
+        await this.setDefaultProfile(args.slice(1), logger);
+        break;
+      case "list":
+        await this.listProfiles(logger);
+        break;
+    }
+  }
+
+  private async addProfile(args: string[], logger: Logger): Promise<void> {
+    const profileName = args[0];
+    if (!profileName) {
+      throw new GemitermError("Usage: profile add <name>");
+    }
+
+    validateProfileName(profileName);
+    logger.debug("Adding profile:", profileName);
+
+    if (listProfiles().includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' already exists.`);
+    }
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    profileManager.create(profileName);
+    console.log(chalk.green(`Profile '${profileName}' created.`));
+
+    const driver = new PlaywrightCliDriver();
+    const cookieMonitor = new CookieMonitor({ driver, logger });
+    const authService = new AuthService({
+      driver,
+      cookieMonitor,
+      cookieStorage,
+      logger,
+    });
+
+    await authService.authenticate(profileName);
+  }
+
+  private async deleteProfile(args: string[], logger: Logger): Promise<void> {
+    const profileName = args[0];
+    if (!profileName) {
+      throw new GemitermError("Usage: profile delete <name>");
+    }
+
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    logger.debug("Deleting profile:", profileName);
+
+    const confirm = await this.promptInput(`Delete profile '${profileName}'? [y/N]`);
+    if (!confirm.toLowerCase().startsWith("y")) {
+      console.log(chalk.dim("Cancelled."));
+      return;
+    }
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    profileManager.delete(profileName);
+    logger.info(`Deleted profile: ${profileName}`);
+    console.log(chalk.green(`Profile '${profileName}' deleted.`));
+  }
+
+  private async renameProfile(args: string[], logger: Logger): Promise<void> {
+    const profileName = args[0];
+    const newName = args[1];
+    if (!profileName || !newName) {
+      throw new GemitermError("Usage: profile rename <name> <newName>");
+    }
+
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    validateProfileName(newName);
+    logger.debug("Renaming profile:", profileName, "→", newName);
+
+    if (profiles.includes(newName)) {
+      throw new GemitermError(`Profile '${newName}' already exists.`);
+    }
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    profileManager.rename(profileName, newName);
+    logger.info(`Renamed profile: ${profileName} → ${newName}`);
+    console.log(chalk.green(`Profile renamed: ${profileName} → ${newName}`));
+  }
+
+  private async setDefaultProfile(args: string[], logger: Logger): Promise<void> {
+    const profileName = args[0];
+    if (!profileName) {
+      throw new GemitermError("Usage: profile default <name>");
+    }
+
+    const profiles = listProfiles();
+    if (!profiles.includes(profileName)) {
+      throw new GemitermError(`Profile '${profileName}' does not exist.`);
+    }
+
+    logger.debug("Setting default profile:", profileName);
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    profileManager.setDefault(profileName);
+    setDefaultProfileName(profileName);
+    logger.info(`Set default profile: ${profileName}`);
+    console.log(chalk.green(`Default profile set to '${profileName}'.`));
+  }
+
+  private async listProfiles(logger: Logger): Promise<void> {
+    logger.debug("Listing all profiles");
+    const profileNames = listProfiles();
+    if (profileNames.length === 0) {
+      console.log(chalk.dim("No profiles found. Run 'gemiterm login' to create one."));
+      return;
+    }
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    const defaultName = getDefaultProfileName();
+    const statuses = profileNames.map((name) => {
+      const status = profileManager.getStatus(name);
+      return { ...status, isDefault: name === defaultName };
+    });
+
+    console.log(chalk.bold("Profiles"));
+    console.log(formatProfileTable(statuses));
+
+    const active = statuses.filter((s) => s.isActive);
+    logger.info(`${active.length} of ${statuses.length} profile(s) active`);
+  }
+
+  private showUsage(): void {
+    console.log(chalk.bold("Usage: gemiterm profile <action> [args]"));
+    console.log("");
+    console.log(chalk.bold("Actions:"));
+
+    const maxUsageLen = Math.max(...ACTIONS.map((a) => a.usage.length));
+    for (const action of ACTIONS) {
+      const padded = action.usage.padEnd(maxUsageLen + 2);
+      console.log(`  ${chalk.cyan(padded)}${chalk.dim(action.desc)}`);
+    }
+
+    console.log("");
+    console.log(chalk.dim("Run 'gemiterm profile <action> --help' for more information."));
+  }
+
+  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);
+      });
+    });
+  }
+}

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

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import { CookieStorage, ProfileManager } from "../../infrastructure/storage.ts";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { getConfigDir, ensureConfigDir, listProfiles, getDefaultProfileName } from "../../infrastructure/config.ts";
+import { formatProfileTable } from "../../infrastructure/formatters.ts";
+
+export class StatusCommand implements CliCommand {
+  readonly name = "status";
+  readonly description = "Show configuration and profile status";
+
+  async execute(args: string[], context: CliCommandContext): Promise<void> {
+    const logger = new Logger("status-command");
+    logger.debug("Executing status command", args);
+
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log("Usage: gemiterm status");
+      console.log("");
+      console.log("Show configuration and profile status.");
+      console.log("");
+      console.log("Options:");
+      console.log("  -h, --help    Show this help message");
+      return;
+    }
+
+    ensureConfigDir();
+
+    const configDir = getConfigDir();
+    logger.debug("Config directory:", configDir);
+    console.log(chalk.bold("Configuration"));
+    console.log(`  Directory: ${chalk.cyan(configDir)}`);
+    console.log("");
+
+    const profileNames = listProfiles();
+    logger.debug("Profile scan found:", profileNames);
+    if (profileNames.length === 0) {
+      console.log(chalk.dim("No profiles found. Run 'gemiterm login' to create one."));
+      process.exit(2);
+    }
+
+    const cookieStorage = new CookieStorage();
+    const profileManager = new ProfileManager(cookieStorage);
+    const statuses = profileNames.map((name) => {
+      const status = profileManager.getStatus(name);
+      return { ...status, isDefault: name === getDefaultProfileName() };
+    });
+
+    console.log(chalk.bold("Profiles"));
+    console.log(formatProfileTable(statuses));
+
+    const defaultName = getDefaultProfileName();
+    const active = statuses.filter((s) => s.isActive);
+    if (active.length > 0) {
+      logger.info(`${active.length} of ${statuses.length} profile(s) active`);
+    } else {
+      logger.info("No profiles have valid sessions. Run 'gemiterm login' to authenticate.");
+    }
+  }
+}