gemiterm 2.0.0

package/tests/integration/commands/fetch.test.ts

@@ -0,0 +1,238 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { FetchCommand } from "../../../src/cli/commands/fetch-command.ts";
+import { Mediator } from "../../../src/core/mediator.ts";
+import { QUERY_TYPES, type FetchChatQueryResult } from "../../../src/core/query-handlers.ts";
+import type { CliCommandContext } from "../../../src/cli/command-registry.ts";
+import { setupTestConfig, teardownTestConfig } from "../../setup.ts";
+import { createMockMessageHistory } from "../../fixtures/chat-fixtures.ts";
+import * as configModule from "../../../src/infrastructure/config.ts";
+import { existsSync, unlinkSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("fetch command integration", () => {
+  let command: FetchCommand;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+  let originalEnv: Record<string, string | undefined>;
+  let mediatorSendSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new FetchCommand();
+    context = { verbose: false, mediator: new Mediator() };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+    originalEnv = {
+      GEMITERM_CONFIG_DIR: process.env.GEMITERM_CONFIG_DIR,
+    };
+    const configDir = setupTestConfig("fetch-integration");
+    spyOn(configModule, "getConfigDir").mockReturnValue(configDir);
+    spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
+
+    const mockMessages = createMockMessageHistory({ count: 4 });
+    mediatorSendSpy = spyOn(context.mediator, "send").mockResolvedValue({ messages: mockMessages });
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+    teardownTestConfig(originalEnv);
+  });
+
+  describe("command metadata", () => {
+    test("has correct name and description", () => {
+      expect(command.name).toBe("fetch");
+      expect(command.description).toBe("Fetch and display a conversation");
+    });
+  });
+
+  describe("--help flag", () => {
+    test("--help shows usage information", async () => {
+      await command.execute(["--help"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Usage: gemiterm fetch");
+      expect(output).toContain("--format");
+      expect(output).toContain("--path");
+      expect(output).toContain("--help");
+    });
+
+    test("-h shows usage information", async () => {
+      await command.execute(["-h"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Usage: gemiterm fetch");
+    });
+
+    test("help does not send query to mediator", async () => {
+      await command.execute(["--help"], context);
+
+      expect(mediatorSendSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("fetch with conversation id", () => {
+    test("sends fetch-chat query to mediator with correct id", async () => {
+      await command.execute(["conv-abc123"], context);
+
+      expect(mediatorSendSpy).toHaveBeenCalledTimes(1);
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.type).toBe(QUERY_TYPES.FETCH_CHAT);
+      expect(sentQuery.payload.conversationId).toBe("conv-abc123");
+    });
+
+    test("returns formatted text output by default", async () => {
+      await command.execute(["conv-abc123"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Conversation:");
+      expect(output).toContain("conv-abc123");
+      expect(output).toContain("User:");
+      expect(output).toContain("Model:");
+    });
+
+    test("displays message content in text output", async () => {
+      const mockMessages = createMockMessageHistory({
+        count: 2,
+        contents: ["Hello!", "Hi there!"],
+      });
+      mediatorSendSpy.mockResolvedValue({ messages: mockMessages });
+
+      await command.execute(["conv-xyz"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Hello!");
+      expect(output).toContain("Hi there!");
+    });
+
+    test("shows 'No messages found' when conversation has no messages", async () => {
+      mediatorSendSpy.mockResolvedValue({ messages: [] });
+
+      await command.execute(["conv-empty"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("No messages found");
+    });
+  });
+
+  describe("--format json option", () => {
+    test("outputs valid JSON when --format json", async () => {
+      const mockMessages = createMockMessageHistory({ count: 2 });
+      mediatorSendSpy.mockResolvedValue({ messages: mockMessages });
+
+      await command.execute(["conv-abc123", "--format", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed).toHaveProperty("conversationId", "conv-abc123");
+      expect(parsed).toHaveProperty("messages");
+      expect(parsed.messages).toHaveLength(2);
+    });
+
+    test("-f json also outputs valid JSON", async () => {
+      const mockMessages = createMockMessageHistory({ count: 3 });
+      mediatorSendSpy.mockResolvedValue({ messages: mockMessages });
+
+      await command.execute(["conv-abc123", "-f", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed.messages).toHaveLength(3);
+    });
+
+    test("JSON output contains message roles and content", async () => {
+      const mockMessages = createMockMessageHistory({
+        count: 2,
+        roles: ["user", "model"],
+        contents: ["What is TypeScript?", "TypeScript is a typed superset of JavaScript."],
+      });
+      mediatorSendSpy.mockResolvedValue({ messages: mockMessages });
+
+      await command.execute(["conv-abc123", "--format", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed.messages[0].role).toBe("user");
+      expect(parsed.messages[0].content).toBe("What is TypeScript?");
+      expect(parsed.messages[1].role).toBe("model");
+    });
+  });
+
+  describe("--path option", () => {
+    test("--path writes text output to file", async () => {
+      const outputPath = join(tmpdir(), `fetch-test-${Date.now()}.txt`);
+
+      try {
+        await command.execute(["conv-abc123", "--path", outputPath], context);
+
+        expect(existsSync(outputPath)).toBe(true);
+        const content = readFileSync(outputPath, "utf-8");
+        expect(content).toContain("Conversation:");
+        expect(content).toContain("conv-abc123");
+      } finally {
+        if (existsSync(outputPath)) unlinkSync(outputPath);
+      }
+    });
+
+    test("-p writes text output to file", async () => {
+      const outputPath = join(tmpdir(), `fetch-test-short-${Date.now()}.txt`);
+
+      try {
+        await command.execute(["conv-abc123", "-p", outputPath], context);
+
+        expect(existsSync(outputPath)).toBe(true);
+        const content = readFileSync(outputPath, "utf-8");
+        expect(content).toContain("Conversation:");
+      } finally {
+        if (existsSync(outputPath)) unlinkSync(outputPath);
+      }
+    });
+
+    test("--path with json format writes JSON to file", async () => {
+      const outputPath = join(tmpdir(), `fetch-test-json-${Date.now()}.json`);
+
+      try {
+        await command.execute(["conv-abc123", "--format", "json", "--path", outputPath], context);
+
+        expect(existsSync(outputPath)).toBe(true);
+        const content = readFileSync(outputPath, "utf-8");
+        const parsed = JSON.parse(content);
+        expect(parsed).toHaveProperty("conversationId");
+        expect(parsed).toHaveProperty("messages");
+      } finally {
+        if (existsSync(outputPath)) unlinkSync(outputPath);
+      }
+    });
+  });
+
+  describe("no conversation id", () => {
+    test("does not send fetch-chat query when no id is provided", async () => {
+      const mockListExecute = mock(() => Promise.resolve());
+      const mockListHandler = { name: "list", description: "", execute: mockListExecute };
+      const mockRegistry = {
+        registerAllCommands: mock(() => {}),
+        getHandler: mock(() => mockListHandler),
+      };
+      spyOn(command as any, "invokeListCommand").mockImplementation(() => {});
+
+      await command.execute([], context);
+
+      expect(mediatorSendSpy).not.toHaveBeenCalled();
+      expect((command as any).invokeListCommand).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("error handling", () => {
+    test("propagates mediator errors", async () => {
+      mediatorSendSpy.mockRejectedValue(new Error("Conversation not found"));
+
+      await expect(command.execute(["conv-invalid"], context)).rejects.toThrow("Conversation not found");
+    });
+
+    test("propagates network errors", async () => {
+      mediatorSendSpy.mockRejectedValue(new Error("Network error"));
+
+      await expect(command.execute(["conv-abc123"], context)).rejects.toThrow("Network error");
+    });
+  });
+});

package/tests/integration/commands/list.test.ts

@@ -0,0 +1,281 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { ListCommand } from "../../../src/cli/commands/list-command.ts";
+import { Mediator } from "../../../src/core/mediator.ts";
+import { QUERY_TYPES, type ListChatsQueryPayload, type ListChatsQueryResult } from "../../../src/core/query-handlers.ts";
+import type { CliCommandContext } from "../../../src/cli/command-registry.ts";
+import { setupTestConfig, teardownTestConfig } from "../../setup.ts";
+import { createMockChatList } from "../../fixtures/chat-fixtures.ts";
+import * as configModule from "../../../src/infrastructure/config.ts";
+
+describe("list command integration", () => {
+  let command: ListCommand;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+  let originalEnv: Record<string, string | undefined>;
+  let mediatorSendSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new ListCommand();
+    context = { verbose: false, mediator: new Mediator() };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+    originalEnv = {
+      GEMITERM_CONFIG_DIR: process.env.GEMITERM_CONFIG_DIR,
+    };
+    const configDir = setupTestConfig("list-integration");
+    spyOn(configModule, "getConfigDir").mockReturnValue(configDir);
+    spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
+
+    const mockChats = createMockChatList({ count: 5 });
+    mediatorSendSpy = spyOn(context.mediator, "send").mockResolvedValue({ chats: mockChats });
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+    teardownTestConfig(originalEnv);
+  });
+
+  describe("command metadata", () => {
+    test("has correct name and description", () => {
+      expect(command.name).toBe("list");
+      expect(command.description).toBe("List conversations");
+    });
+  });
+
+  describe("--help flag", () => {
+    test("--help shows usage information", async () => {
+      await command.execute(["--help"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Usage: gemiterm list");
+      expect(output).toContain("--limit");
+      expect(output).toContain("--search");
+      expect(output).toContain("--format");
+    });
+
+    test("-h shows usage information", async () => {
+      await command.execute(["-h"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Usage: gemiterm list");
+    });
+
+    test("help does not send query to mediator", async () => {
+      await command.execute(["--help"], context);
+
+      expect(mediatorSendSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("list with mock data", () => {
+    test("sends list-chats query to mediator", async () => {
+      await command.execute([], context);
+
+      expect(mediatorSendSpy).toHaveBeenCalledTimes(1);
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.type).toBe(QUERY_TYPES.LIST_CHATS);
+    });
+
+    test("returns formatted table output by default", async () => {
+      await command.execute([], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("ID");
+      expect(output).toContain("TITLE");
+      expect(output).toContain("DATE");
+      expect(output).toContain("Total:");
+    });
+
+    test("displays chat IDs in output", async () => {
+      const mockChats = createMockChatList({ count: 3 });
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute([], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      for (const chat of mockChats) {
+        expect(output).toContain(chat.id);
+      }
+    });
+
+    test("displays empty message when no chats", async () => {
+      mediatorSendSpy.mockResolvedValue({ chats: [] });
+
+      await command.execute([], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("No conversations found");
+    });
+  });
+
+  describe("--limit option", () => {
+    test("--limit 2 passes limit to mediator query", async () => {
+      await command.execute(["--limit", "2"], context);
+
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.payload.limit).toBe(2);
+    });
+
+    test("-n 5 passes limit to mediator query", async () => {
+      await command.execute(["-n", "5"], context);
+
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.payload.limit).toBe(5);
+    });
+
+    test("limits output to specified number of results", async () => {
+      const mockChats = createMockChatList({ count: 10 });
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute(["--limit", "3"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const lines = output.split("\n");
+      const dataLines = lines.filter((l) => l.includes("\u2502") && !l.includes("Total:"));
+      expect(dataLines.length).toBeLessThanOrEqual(4);
+    });
+  });
+
+  describe("--format json option", () => {
+    test("outputs valid JSON when --format json", async () => {
+      const mockChats = createMockChatList({ count: 3 });
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute(["--format", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed).toHaveProperty("chats");
+      expect(parsed.chats).toHaveLength(3);
+    });
+
+    test("-f json also outputs valid JSON", async () => {
+      const mockChats = createMockChatList({ count: 2 });
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute(["-f", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed.chats).toHaveLength(2);
+    });
+
+    test("JSON output contains chat ids and titles", async () => {
+      const mockChats = createMockChatList({ count: 2, ids: ["id-one", "id-two"], titles: ["First", "Second"] });
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute(["--format", "json"], context);
+
+      const jsonOutput = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsed = JSON.parse(jsonOutput);
+      expect(parsed.chats[0].id).toBe("id-one");
+      expect(parsed.chats[0].title).toBe("First");
+    });
+  });
+
+  describe("--search option", () => {
+    test("--search passes search term to mediator query", async () => {
+      await command.execute(["--search", "TypeScript"], context);
+
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.payload.search).toBe("TypeScript");
+    });
+
+    test("-s passes search term to mediator query", async () => {
+      await command.execute(["-s", "Bun"], context);
+
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.payload.search).toBe("Bun");
+    });
+  });
+
+  describe("--all flag", () => {
+    test("--all sends query without limit", async () => {
+      await command.execute(["--all"], context);
+
+      const sentQuery = mediatorSendSpy.mock.calls[0][0] as any;
+      expect(sentQuery.payload.limit).toBeUndefined();
+    });
+  });
+
+  describe("sort options", () => {
+    test("default sort is recent", async () => {
+      await command.execute([], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("Total:");
+    });
+
+    test("--sort oldest is accepted", async () => {
+      await command.execute(["--sort", "oldest"], context);
+
+      expect(mediatorSendSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("--sort alpha is accepted", async () => {
+      await command.execute(["--sort", "alpha"], context);
+
+      expect(mediatorSendSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("--all-profiles flag", () => {
+    test("renders Profile column when --all-profiles is set", async () => {
+      const mockChats = [
+        { id: "conv-1", title: "Chat 1", isPinned: false, timestamp: Date.now(), profile: "work" },
+        { id: "conv-2", title: "Chat 2", isPinned: false, timestamp: Date.now(), profile: "personal" },
+      ];
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute(["--all-profiles"], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).toContain("PROFILE");
+      expect(output).toContain("work");
+      expect(output).toContain("personal");
+    });
+
+    test("omits Profile column when --all-profiles is not set", async () => {
+      const mockChats = [
+        { id: "conv-1", title: "Chat 1", isPinned: false, timestamp: Date.now(), profile: "work" },
+      ];
+      mediatorSendSpy.mockResolvedValue({ chats: mockChats });
+
+      await command.execute([], context);
+
+      const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      expect(output).not.toContain("PROFILE");
+    });
+
+    test("JSON output includes profile field only when --all-profiles is set", async () => {
+      const mockChatsWithProfile = [
+        { id: "conv-1", title: "Chat 1", isPinned: false, timestamp: Date.now(), profile: "work" },
+      ];
+      mediatorSendSpy.mockResolvedValue({ chats: mockChatsWithProfile });
+
+      await command.execute(["--all-profiles", "--format", "json"], context);
+      const outputWithFlag = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsedWithFlag = JSON.parse(outputWithFlag);
+      expect(parsedWithFlag.chats[0]).toHaveProperty("profile");
+      expect(parsedWithFlag.chats[0].profile).toBe("work");
+
+      const mockChatsWithoutProfile = [
+        { id: "conv-1", title: "Chat 1", isPinned: false, timestamp: Date.now() },
+      ];
+      logSpy.mockClear();
+      mediatorSendSpy.mockResolvedValue({ chats: mockChatsWithoutProfile });
+      await command.execute(["--format", "json"], context);
+      const outputWithoutFlag = logSpy.mock.calls.map((c) => c[0]).join("\n");
+      const parsedWithoutFlag = JSON.parse(outputWithoutFlag);
+      expect(parsedWithoutFlag.chats[0]).not.toHaveProperty("profile");
+    });
+  });
+
+  describe("error handling", () => {
+    test("propagates mediator errors", async () => {
+      mediatorSendSpy.mockRejectedValue(new Error("Network error"));
+
+      await expect(command.execute([], context)).rejects.toThrow("Network error");
+    });
+  });
+});