gemiterm 2.0.0

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

@@ -0,0 +1,67 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { CommandRegistry } from "../../src/cli/command-registry.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommand, CliCommandContext } from "../../src/cli/command-registry.ts";
+
+class FakeCommand implements CliCommand {
+  constructor(
+    public readonly name: string,
+    public readonly description: string,
+    private readonly executeFn: (args: string[], ctx: CliCommandContext) => Promise<void>,
+  ) {}
+
+  async execute(args: string[], ctx: CliCommandContext): Promise<void> {
+    return this.executeFn(args, ctx);
+  }
+}
+
+describe("CommandRegistry", () => {
+  let registry: CommandRegistry;
+
+  beforeEach(() => {
+    registry = new CommandRegistry();
+  });
+
+  test("registers and retrieves a command handler", () => {
+    const handler = new FakeCommand("test", "A test command", async () => {});
+    registry.register("test", handler);
+    expect(registry.getHandler("test")).toBe(handler);
+  });
+
+  test("returns undefined for unregistered command", () => {
+    expect(registry.getHandler("nonexistent")).toBeUndefined();
+  });
+
+  test("throws when registering duplicate command", () => {
+    const handler = new FakeCommand("dup", "desc", async () => {});
+    registry.register("dup", handler);
+    expect(() => registry.register("dup", handler)).toThrow("Command already registered: dup");
+  });
+
+  test("has() returns correct boolean", () => {
+    registry.register("exists", new FakeCommand("exists", "desc", async () => {}));
+    expect(registry.has("exists")).toBe(true);
+    expect(registry.has("nope")).toBe(false);
+  });
+
+  test("getRegisteredNames() returns all registered names", () => {
+    registry.register("login", new FakeCommand("login", "Login", async () => {}));
+    registry.register("list", new FakeCommand("list", "List", async () => {}));
+    const names = registry.getRegisteredNames();
+    expect(names).toContain("login");
+    expect(names).toContain("list");
+    expect(names).toHaveLength(2);
+  });
+
+  test("execute dispatches to correct handler", async () => {
+    const executeMock = mock(() => Promise.resolve());
+    const handler = new FakeCommand("greet", "Greet", executeMock);
+    registry.register("greet", handler);
+
+    const ctx: CliCommandContext = { verbose: false, mediator: new Mediator() };
+    await registry.getHandler("greet")!.execute(["--name", "World"], ctx);
+
+    expect(executeMock).toHaveBeenCalledWith(["--name", "World"], ctx);
+    expect(executeMock).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,100 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { ContinueCommand } from "../../src/cli/commands/continue-command.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommandContext } from "../../src/cli/command-registry.ts";
+import { COMMAND_TYPES } from "../../src/core/command-handlers.ts";
+import { QUERY_TYPES } from "../../src/core/query-handlers.ts";
+
+describe("ContinueCommand", () => {
+  let command: ContinueCommand;
+  let mediator: Mediator;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new ContinueCommand();
+    mediator = new Mediator();
+    context = {
+      verbose: false,
+      mediator,
+      profileAuthManager: {
+        getActiveProfiles: mock(() => ["default"]),
+        findProfileForConversation: mock(() => null),
+        ensureAuthenticated: mock(() => ({ secure_1psid: "", secure_1psidts: null })),
+      } as unknown as CliCommandContext["profileAuthManager"],
+    };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("continue");
+    expect(command.description).toBe("Continue a conversation");
+  });
+
+  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 continue");
+    expect(output).toContain("conversation_id");
+    expect(output).toContain("/exit");
+  });
+
+  test("shows help with -h flag", async () => {
+    await command.execute(["-h"], context);
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Usage: gemiterm continue");
+  });
+
+  test("sends message in non-interactive mode with conversation_id and message", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.SEND_MESSAGE,
+      handle: mock(async () => ({ response: "Hello from Gemini!" })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["conv123", "Hello there"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Model:");
+    expect(output).toContain("Hello from Gemini!");
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: COMMAND_TYPES.SEND_MESSAGE,
+        payload: expect.objectContaining({
+          conversationId: "conv123",
+          message: "Hello there",
+        }),
+      }),
+    );
+  });
+
+  test("sends correct command type via mediator", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.SEND_MESSAGE,
+      handle: mock(async () => ({ response: "ok" })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["conv-id", "test message"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledTimes(1);
+  });
+
+  test("invokes list command when no conversation_id provided", async () => {
+    const mockListHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: [] })),
+    };
+    mediator.registerQueryHandler(mockListHandler as any);
+
+    await command.execute([], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Listing conversations");
+  });
+});

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

@@ -0,0 +1,128 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { DeleteCommand } from "../../src/cli/commands/delete-command.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommandContext } from "../../src/cli/command-registry.ts";
+import { COMMAND_TYPES } from "../../src/core/command-handlers.ts";
+
+describe("DeleteCommand", () => {
+  let command: DeleteCommand;
+  let mediator: Mediator;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+  let errorSpy: ReturnType<typeof spyOn>;
+  let exitSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new DeleteCommand();
+    mediator = new Mediator();
+    context = {
+      verbose: false,
+      mediator,
+      profileAuthManager: {
+        getActiveProfiles: mock(() => ["default"]),
+        findProfileForConversation: mock(() => null),
+        ensureAuthenticated: mock(() => ({ secure_1psid: "", secure_1psidts: null })),
+      } as unknown as CliCommandContext["profileAuthManager"],
+    };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+    errorSpy = spyOn(console, "error").mockImplementation(() => {});
+    exitSpy = spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("delete");
+    expect(command.description).toBe("Delete a conversation");
+  });
+
+  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 delete");
+    expect(output).toContain("--force");
+    expect(output).toContain("--help");
+  });
+
+  test("shows error when no conversation ID provided", async () => {
+    await expect(command.execute([], context)).rejects.toThrow("process.exit called");
+
+    const errorOutput = errorSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(errorOutput).toContain("conversation ID is required");
+  });
+
+  test("sends delete-conversation command with --force flag", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.DELETE_CONVERSATION,
+      handle: mock(async () => ({ success: true })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["abc123", "--force"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({ conversationId: "abc123" }),
+      }),
+    );
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("abc123");
+    expect(output).toContain("deleted");
+  });
+
+  test("sends delete-conversation command with -f short flag", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.DELETE_CONVERSATION,
+      handle: mock(async () => ({ success: true })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["abc123", "-f"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({ conversationId: "abc123" }),
+      }),
+    );
+  });
+
+  test("handles failed deletion", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.DELETE_CONVERSATION,
+      handle: mock(async () => ({ success: false })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await expect(command.execute(["abc123", "--force"], context)).rejects.toThrow(
+      "process.exit called",
+    );
+
+    const errorOutput = errorSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(errorOutput).toContain("Failed to delete conversation");
+  });
+
+  test("handles error from handler", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.DELETE_CONVERSATION,
+      handle: mock(async () => {
+        throw new Error("Network error");
+      }),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await expect(command.execute(["abc123", "--force"], context)).rejects.toThrow(
+      "process.exit called",
+    );
+
+    const errorOutput = errorSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(errorOutput).toContain("Network error");
+  });
+});

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

@@ -0,0 +1,375 @@
+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");
+  });
+});