gemiterm 2.0.0 → 2.1.0

package/tests/cli/export-all-command.test.ts

@@ -1,375 +0,0 @@
-import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { ExportAllCommand } from "../../src/cli/commands/export-all-command.ts";
-import { Mediator } from "../../src/core/mediator.ts";
-import type { CliCommandContext } from "../../src/cli/command-registry.ts";
-import { QUERY_TYPES } from "../../src/core/query-handlers.ts";
-import { mkdirSync, readFileSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-const SAMPLE_CHATS = [
-  { id: "abc123", title: "Python tips", isPinned: true, timestamp: 1717000000000 },
-  { id: "def456", title: "Bun setup", isPinned: false, timestamp: 1717100000000 },
-];
-
-const SAMPLE_MESSAGES = [
-  { role: "user" as const, content: "Hello" },
-  { role: "model" as const, content: "Hi there!" },
-];
-
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-
-function stripAnsi(value: string): string {
-  return value.replace(ANSI_RE, "");
-}
-
-function capturedLog(spy: ReturnType<typeof spyOn>): string {
-  return stripAnsi(spy.mock.calls.map((c) => c[0]).join("\n"));
-}
-
-function capturedStdout(spy: ReturnType<typeof spyOn>): string {
-  return stripAnsi(spy.mock.calls.map((c) => c[0]).join(""));
-}
-
-describe("ExportAllCommand", () => {
-  let command: ExportAllCommand;
-  let mediator: Mediator;
-  let context: CliCommandContext;
-  let logSpy: ReturnType<typeof spyOn>;
-  let writeSpy: ReturnType<typeof spyOn>;
-  let tempDir: string;
-
-  beforeEach(() => {
-    command = new ExportAllCommand();
-    mediator = new Mediator();
-    tempDir = join(tmpdir(), `export-all-test-${Date.now()}`);
-    mkdirSync(tempDir, { recursive: true });
-    context = { verbose: false, mediator };
-    logSpy = spyOn(console, "log").mockImplementation(() => {});
-    writeSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
-  });
-
-  afterEach(() => {
-    mock.restore();
-    logSpy.mockRestore();
-    writeSpy.mockRestore();
-    try {
-      rmSync(tempDir, { recursive: true, force: true });
-    } catch {}
-  });
-
-  test("has correct name and description", () => {
-    expect(command.name).toBe("export-all");
-    expect(command.description).toBe("Export all conversations to files");
-  });
-
-  test("shows help with --help flag", async () => {
-    await command.execute(["--help"], context);
-    const output = capturedLog(logSpy);
-    expect(output).toContain("Usage: gemiterm export-all");
-    expect(output).toContain("--output-dir");
-    expect(output).toContain("--since");
-    expect(output).toContain("--all-profiles");
-  });
-
-  test("exports all chats and creates index.md", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const indexPath = join(tempDir, "index.md");
-    expect(existsSync(indexPath)).toBeTrue();
-
-    const indexContent = readFileSync(indexPath, "utf-8");
-    expect(indexContent).toContain("Exported Conversations");
-    expect(indexContent).toContain("Python tips");
-    expect(indexContent).toContain("Bun setup");
-  });
-
-  test("creates individual export files for each chat", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const files = readFileSync(join(tempDir, "index.md"), "utf-8");
-    const mdFiles = files.match(/\.md\)/g);
-    expect(mdFiles).toHaveLength(2);
-  });
-
-  test("shows no conversations message when empty", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [] })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const output = capturedLog(logSpy);
-    expect(output).toContain("No conversations found");
-  });
-
-  test("passes allProfiles flag to query", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--all-profiles", "--output-dir", tempDir], context);
-
-    expect(listHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({ allProfiles: true }),
-      }),
-    );
-  });
-
-  test("filters by --since date", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--since", "2024-01-01", "--output-dir", tempDir], context);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    const mdFiles = indexContent.match(/\.md\)/g);
-    expect(mdFiles).toHaveLength(2);
-  });
-
-  test("reports failed exports in summary and index", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    let callCount = 0;
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => {
-        callCount++;
-        if (callCount === 1) return { messages: SAMPLE_MESSAGES };
-        throw new Error("Network error");
-      }),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const output = capturedLog(logSpy);
-    expect(output).toMatch(/Exported:\s+1/);
-    expect(output).toMatch(/Failed:\s+1/);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("Failed Exports");
-    expect(indexContent).toContain("Network error");
-  });
-
-  test("shows progress output during export", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const progressOutput = capturedStdout(writeSpy);
-    expect(progressOutput).toContain("[1/2]");
-    expect(progressOutput).toContain("[2/2]");
-  });
-
-  test("uses --include-metadata in index", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--include-metadata", "--output-dir", tempDir], context);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("Successful:");
-    expect(indexContent).toContain("Failed:");
-  });
-
-  test("defaults output directory to ./exports", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [] })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-
-    await command.execute([], context);
-    const output = capturedLog(logSpy);
-    expect(output).toContain("No conversations found");
-  });
-
-  test("handles all exports failing", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => {
-        throw new Error("boom");
-      }),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const output = capturedLog(logSpy);
-    expect(output).toMatch(/Exported:\s+0/);
-    expect(output).toMatch(/Failed:\s+2/);
-    expect(output).toMatch(/Index:/);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("Failed Exports");
-    expect(indexContent).toContain("Python tips");
-    expect(indexContent).toContain("Bun setup");
-    expect(indexContent).toContain("boom");
-  });
-
-  test("preserves non-Error throw values in failure output", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [SAMPLE_CHATS[0]] })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => {
-        throw "string-failure";
-      }),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", tempDir], context);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("string-failure");
-  });
-
-  test("creates the output directory when it does not exist", async () => {
-    const nested = join(tempDir, "deep", "nested", "out");
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--output-dir", nested], context);
-
-    expect(existsSync(nested)).toBeTrue();
-    expect(existsSync(join(nested, "index.md"))).toBeTrue();
-  });
-
-  test("accepts -a short form for --all-profiles", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["-a", "--output-dir", tempDir], context);
-
-    expect(listHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({ allProfiles: true }),
-      }),
-    );
-  });
-
-  test("ignores invalid --since date and exports all chats", async () => {
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--since", "not-a-date", "--output-dir", tempDir], context);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("Python tips");
-    expect(indexContent).toContain("Bun setup");
-  });
-
-  test("filters out chats older than --since date", async () => {
-    const oldChat = { id: "old1", title: "Old chat", isPinned: false, timestamp: 1577836800000 };
-    const newChat = { id: "new1", title: "New chat", isPinned: false, timestamp: 1717200000000 };
-    const listHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [oldChat, newChat] })),
-    };
-    const fetchHandler = {
-      queryType: QUERY_TYPES.FETCH_CHAT,
-      handle: mock(async () => ({ messages: SAMPLE_MESSAGES })),
-    };
-    mediator.registerQueryHandler(listHandler as any);
-    mediator.registerQueryHandler(fetchHandler as any);
-
-    await command.execute(["--since", "2024-01-01", "--output-dir", tempDir], context);
-
-    const indexContent = readFileSync(join(tempDir, "index.md"), "utf-8");
-    expect(indexContent).toContain("New chat");
-    expect(indexContent).not.toContain("Old chat");
-  });
-});

package/tests/cli/install-browser-command.test.ts

@@ -1,48 +0,0 @@
-import { describe, test, expect, beforeEach, mock, spyOn } from "bun:test";
-import { InstallBrowserCommand } from "../../src/cli/commands/install-browser-command.ts";
-import { InstallBrowserService, InstallBrowserError } from "../../src/services/install-browser-service.ts";
-
-describe("InstallBrowserCommand", () => {
-  let command: InstallBrowserCommand;
-
-  beforeEach(() => {
-    command = new InstallBrowserCommand();
-  });
-
-  test("has correct name and description", () => {
-    expect(command.name).toBe("install-browser");
-    expect(command.description).toContain("Chromium");
-  });
-
-  test("implements CliCommand interface", () => {
-    expect(typeof command.execute).toBe("function");
-  });
-
-  test("exits with code 1 on InstallBrowserError", async () => {
-    const exitSpy = spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process.exit");
-    });
-
-    const service = new InstallBrowserService();
-    spyOn(service, "install").mockImplementation(async () => {
-      throw new InstallBrowserError("install failed");
-    });
-
-    const spy = spyOn(InstallBrowserService.prototype, "install").mockImplementation(async () => {
-      throw new InstallBrowserError("install failed");
-    });
-
-    await expect(command.execute([], { verbose: false })).rejects.toThrow("process.exit");
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    spy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  test("succeeds when install completes", async () => {
-    const spy = spyOn(InstallBrowserService.prototype, "install").mockResolvedValue(undefined);
-
-    await expect(command.execute([], { verbose: false })).resolves.toBeUndefined();
-    spy.mockRestore();
-  });
-});

package/tests/cli/list-command.test.ts

@@ -1,179 +0,0 @@
-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 type { CliCommandContext } from "../../src/cli/command-registry.ts";
-import { QUERY_TYPES } from "../../src/core/query-handlers.ts";
-import type { ListChatsQueryResult } from "../../src/core/query-handlers.ts";
-
-const SAMPLE_CHATS = [
-  { id: "abc123", title: "Python tips", isPinned: true, timestamp: 1717000000000 },
-  { id: "def456", title: "Bun setup", isPinned: false, timestamp: 1717100000000 },
-  { id: "ghi789", title: "Alpha test", isPinned: false, timestamp: 1716900000000 },
-];
-
-describe("ListCommand", () => {
-  let command: ListCommand;
-  let mediator: Mediator;
-  let context: CliCommandContext;
-  let logSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    command = new ListCommand();
-    mediator = new Mediator();
-    context = { verbose: false, mediator };
-    logSpy = spyOn(console, "log").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    mock.restore();
-    logSpy.mockRestore();
-  });
-
-  test("has correct name and description", () => {
-    expect(command.name).toBe("list");
-    expect(command.description).toBe("List conversations");
-  });
-
-  test("shows help with --help flag", 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("--format");
-  });
-
-  test("sends list-chats query and displays results", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute([], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("abc123");
-    expect(output).toContain("Python tips");
-    expect(output).toContain("Total: 3 conversations");
-  });
-
-  test("applies limit", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--limit", "1"], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("Total: 1 conversation");
-  });
-
-  test("applies search filter", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => {
-        const filtered = SAMPLE_CHATS.filter((c) => c.title.toLowerCase().includes("bun"));
-        return { chats: filtered };
-      }),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--search", "Bun"], context);
-
-    expect(mockHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({ search: "Bun" }),
-      }),
-    );
-  });
-
-  test("applies --all flag", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--all"], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("Total: 3 conversations");
-  });
-
-  test("applies sort by alpha", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--sort", "alpha"], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    const alphaIdx = output.indexOf("Alpha test");
-    const bunIdx = output.indexOf("Bun setup");
-    const pythonIdx = output.indexOf("Python tips");
-    expect(alphaIdx).toBeLessThan(bunIdx);
-    expect(bunIdx).toBeLessThan(pythonIdx);
-  });
-
-  test("outputs JSON format", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--format", "json"], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    const parsed = JSON.parse(output);
-    expect(parsed).toHaveProperty("chats");
-    expect(parsed.chats).toHaveLength(3);
-  });
-
-  test("shows no conversations message when empty", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [] })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute([], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("No conversations found");
-  });
-
-  test("applies --all-profiles flag in query", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: [] })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--all-profiles"], context);
-
-    expect(mockHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({ allProfiles: true }),
-      }),
-    );
-  });
-
-  test("applies --offset flag", async () => {
-    const mockHandler = {
-      queryType: QUERY_TYPES.LIST_CHATS,
-      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
-    };
-    mediator.registerQueryHandler(mockHandler as any);
-
-    await command.execute(["--offset", "2", "--limit", "1"], context);
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("ghi789");
-    expect(output).toContain("Total: 1 conversation");
-  });
-});