gemiterm 2.0.0 → 2.1.1

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

@@ -1,139 +0,0 @@
-import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { NewCommand } from "../../src/cli/commands/new-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("NewCommand", () => {
-  let command: NewCommand;
-  let mediator: Mediator;
-  let context: CliCommandContext;
-  let logSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    command = new NewCommand();
-    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("new");
-    expect(command.description).toBe("Start a new 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 new");
-    expect(output).toContain("--profile");
-    expect(output).toContain("message");
-  });
-
-  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 new");
-  });
-
-  test("sends start-new-chat command with message", async () => {
-    const mockHandler = {
-      commandType: COMMAND_TYPES.START_NEW_CHAT,
-      handle: mock(async () => ({
-        response: "Hello from Gemini!",
-        conversationId: "conv-123",
-      })),
-    };
-    mediator.registerCommandHandler(mockHandler as any);
-
-    await command.execute(["Hello there"], context);
-
-    expect(mockHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: COMMAND_TYPES.START_NEW_CHAT,
-        payload: expect.objectContaining({
-          message: "Hello there",
-        }),
-      }),
-    );
-
-    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
-    expect(output).toContain("conv-123");
-    expect(output).toContain("Hello from Gemini!");
-  });
-
-  test("sends start-new-chat command with profile specified via -p", async () => {
-    const mockHandler = {
-      commandType: COMMAND_TYPES.START_NEW_CHAT,
-      handle: mock(async () => ({
-        response: "Hello from Gemini!",
-        conversationId: "conv-456",
-      })),
-    };
-    mediator.registerCommandHandler(mockHandler as any);
-
-    await command.execute(["-p", "dhb-worker", "a new test message"], context);
-
-    expect(mockHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: COMMAND_TYPES.START_NEW_CHAT,
-        payload: expect.objectContaining({
-          message: "a new test message",
-          profileName: "dhb-worker",
-        }),
-      }),
-    );
-  });
-
-  test("sends start-new-chat command with profile specified via --profile", async () => {
-    const mockHandler = {
-      commandType: COMMAND_TYPES.START_NEW_CHAT,
-      handle: mock(async () => ({
-        response: "Hello from Gemini!",
-        conversationId: "conv-789",
-      })),
-    };
-    mediator.registerCommandHandler(mockHandler as any);
-
-    await command.execute(["--profile", "my-profile", "test message"], context);
-
-    expect(mockHandler.handle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: COMMAND_TYPES.START_NEW_CHAT,
-        payload: expect.objectContaining({
-          message: "test message",
-          profileName: "my-profile",
-        }),
-      }),
-    );
-  });
-
-  test("does not include profileName in payload when no profile specified", async () => {
-    const mockHandler = {
-      commandType: COMMAND_TYPES.START_NEW_CHAT,
-      handle: mock(async () => ({
-        response: "Hello",
-        conversationId: "conv-abc",
-      })),
-    };
-    mediator.registerCommandHandler(mockHandler as any);
-
-    await command.execute(["hello"], context);
-
-    const call = mockHandler.handle.mock.calls[0][0];
-    expect(call.payload.profileName).toBeUndefined();
-  });
-});

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

@@ -1,106 +0,0 @@
-import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { StatusCommand } from "../../src/cli/commands/status-command.ts";
-import { Mediator } from "../../src/core/mediator.ts";
-import type { CliCommandContext } from "../../src/cli/command-registry.ts";
-import * as configModule from "../../src/infrastructure/config.ts";
-
-describe("StatusCommand", () => {
-  let command: StatusCommand;
-  let context: CliCommandContext;
-  let exitSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    command = new StatusCommand();
-    context = { verbose: false, mediator: new Mediator() };
-    exitSpy = spyOn(process, "exit").mockImplementation((code?: number) => {
-      throw new Error(`process.exit(${code})`);
-    });
-  });
-
-  afterEach(() => {
-    mock.restore();
-    exitSpy.mockRestore();
-  });
-
-  test("has correct name and description", () => {
-    expect(command.name).toBe("status");
-    expect(command.description).toBe("Show configuration and profile status");
-  });
-
-  describe("execute", () => {
-    test("exits with code 2 when no profiles exist", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue([]);
-      spyOn(configModule, "getConfigDir").mockReturnValue("/tmp/gemiterm");
-      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
-      spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
-      spyOn(console, "log").mockImplementation(() => {});
-
-      await expect(command.execute([], context)).rejects.toThrow("process.exit(2)");
-    });
-
-    test("displays config directory and profile table", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["default"]);
-      spyOn(configModule, "getConfigDir").mockReturnValue("/home/user/.config/gemiterm");
-      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
-      spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
-
-      const logOutput: string[] = [];
-      spyOn(console, "log").mockImplementation((...args) => {
-        logOutput.push(args.join(" "));
-      });
-
-      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
-      const mockGetStatus = mock(() => ({
-        name: "default",
-        exists: true,
-        isActive: true,
-        expiresAt: "2026-07-01T00:00:00.000Z",
-        isDefault: true,
-      }));
-      const origProto = ProfileManager.prototype.getStatus;
-      ProfileManager.prototype.getStatus = mockGetStatus;
-
-      try {
-        await command.execute([], context);
-
-        const combined = logOutput.join("\n");
-        expect(combined).toContain("Configuration");
-        expect(combined).toContain("/home/user/.config/gemiterm");
-        expect(combined).toContain("Profiles");
-        expect(combined).toContain("default");
-      } finally {
-        ProfileManager.prototype.getStatus = origProto;
-      }
-    });
-
-    test("displays multiple profiles with correct default marker", async () => {
-      spyOn(configModule, "listProfiles").mockReturnValue(["work", "personal"]);
-      spyOn(configModule, "getConfigDir").mockReturnValue("/home/user/.config/gemiterm");
-      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
-      spyOn(configModule, "getDefaultProfileName").mockReturnValue("work");
-
-      const logOutput: string[] = [];
-      spyOn(console, "log").mockImplementation((...args) => {
-        logOutput.push(args.join(" "));
-      });
-
-      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
-      const statuses = {
-        work: { name: "work", exists: true, isActive: true, expiresAt: "2026-08-01T00:00:00.000Z", isDefault: true },
-        personal: { name: "personal", exists: true, isActive: false, expiresAt: null, isDefault: false },
-      };
-      const origProto = ProfileManager.prototype.getStatus;
-      ProfileManager.prototype.getStatus = mock((name: string) => statuses[name as keyof typeof statuses]);
-
-      try {
-        await command.execute([], context);
-
-        const combined = logOutput.join("\n");
-        expect(combined).toContain("work");
-        expect(combined).toContain("personal");
-      } finally {
-        ProfileManager.prototype.getStatus = origProto;
-      }
-    });
-  });
-});

package/tests/core/query-handlers.test.ts

@@ -1,187 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test";
-import {
-  ListChatsQueryHandler,
-  FetchChatQueryHandler,
-  GetProfileStatusesQueryHandler,
-  GetAuthStatusQueryHandler,
-  ListModelsQueryHandler,
-  QUERY_TYPES,
-} from "../../src/core/query-handlers.ts";
-import type { IGeminiClientQueryService, IProfileQueryService } from "../../src/core/query-handlers.ts";
-import type { Query } from "../../src/core/mediator.ts";
-
-function makeQuery<T>(type: string, payload: T): Query<T> {
-  return { type, payload: payload as unknown as Record<string, unknown> };
-}
-
-describe("ListChatsQueryHandler", () => {
-  let mockClient: IGeminiClientQueryService & { forProfile: (name: string) => IGeminiClientQueryService };
-
-  beforeEach(() => {
-    mockClient = {
-      listChats: mock(() => Promise.resolve([])),
-      fetchChat: mock(() => Promise.resolve([])),
-      listModels: mock(() => Promise.resolve([])),
-      forProfile: (name: string) => mockClient,
-    };
-  });
-
-  test("has correct queryType", () => {
-    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
-    expect(handler.queryType).toBe(QUERY_TYPES.LIST_CHATS);
-  });
-
-  test("returns chats from gemini client", async () => {
-    const chats = [
-      { id: "1", title: "Chat 1", isPinned: false, timestamp: 1000 },
-      { id: "2", title: "Chat 2", isPinned: true, timestamp: 2000 },
-    ];
-    mockClient.listChats = mock(() => Promise.resolve(chats));
-
-    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
-    const result = await handler.handle(makeQuery(QUERY_TYPES.LIST_CHATS, {}));
-    expect(result.chats).toEqual(chats);
-  });
-
-  test("passes limit, offset, search options", async () => {
-    mockClient.listChats = mock((opts) => {
-      expect(opts).toEqual({ limit: 10, offset: 5, search: "hello" });
-      return Promise.resolve([]);
-    });
-
-    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
-    await handler.handle(
-      makeQuery(QUERY_TYPES.LIST_CHATS, { limit: 10, offset: 5, search: "hello" }),
-    );
-    expect(mockClient.listChats).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("FetchChatQueryHandler", () => {
-  let mockClient: IGeminiClientQueryService;
-
-  beforeEach(() => {
-    mockClient = {
-      listChats: mock(() => Promise.resolve([])),
-      fetchChat: mock(() => Promise.resolve([])),
-      listModels: mock(() => Promise.resolve([])),
-    };
-  });
-
-  test("has correct queryType", () => {
-    const handler = new FetchChatQueryHandler(mockClient);
-    expect(handler.queryType).toBe(QUERY_TYPES.FETCH_CHAT);
-  });
-
-  test("returns messages for conversation", async () => {
-    const messages = [
-      { role: "user" as const, content: "Hello" },
-      { role: "model" as const, content: "Hi there!" },
-    ];
-    mockClient.fetchChat = mock(() => Promise.resolve(messages));
-
-    const handler = new FetchChatQueryHandler(mockClient);
-    const result = await handler.handle(
-      makeQuery(QUERY_TYPES.FETCH_CHAT, { conversationId: "conv-123" }),
-    );
-    expect(result.messages).toEqual(messages);
-    expect(mockClient.fetchChat).toHaveBeenCalledWith("conv-123");
-  });
-});
-
-describe("GetProfileStatusesQueryHandler", () => {
-  let mockProfileService: IProfileQueryService;
-
-  beforeEach(() => {
-    mockProfileService = {
-      getProfileStatuses: mock(() => Promise.resolve([])),
-      getAuthStatus: mock(() => Promise.resolve({ authenticated: false, profileName: null })),
-    };
-  });
-
-  test("has correct queryType", () => {
-    const handler = new GetProfileStatusesQueryHandler(mockProfileService);
-    expect(handler.queryType).toBe(QUERY_TYPES.GET_PROFILE_STATUSES);
-  });
-
-  test("returns profile statuses", async () => {
-    const statuses = [
-      {
-        name: "default",
-        exists: true,
-        isActive: true,
-        expiresAt: "2099-01-01T00:00:00Z",
-        isDefault: true,
-      },
-    ];
-    mockProfileService.getProfileStatuses = mock(() => Promise.resolve(statuses));
-
-    const handler = new GetProfileStatusesQueryHandler(mockProfileService);
-    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_PROFILE_STATUSES, {}));
-    expect(result.statuses).toEqual(statuses);
-  });
-});
-
-describe("GetAuthStatusQueryHandler", () => {
-  let mockProfileService: IProfileQueryService;
-
-  beforeEach(() => {
-    mockProfileService = {
-      getProfileStatuses: mock(() => Promise.resolve([])),
-      getAuthStatus: mock(() => Promise.resolve({ authenticated: false, profileName: null })),
-    };
-  });
-
-  test("has correct queryType", () => {
-    const handler = new GetAuthStatusQueryHandler(mockProfileService);
-    expect(handler.queryType).toBe(QUERY_TYPES.GET_AUTH_STATUS);
-  });
-
-  test("returns authenticated true with profile name", async () => {
-    mockProfileService.getAuthStatus = mock(() =>
-      Promise.resolve({ authenticated: true, profileName: "default" }),
-    );
-
-    const handler = new GetAuthStatusQueryHandler(mockProfileService);
-    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_AUTH_STATUS, {}));
-    expect(result.authenticated).toBe(true);
-    expect(result.profileName).toBe("default");
-  });
-
-  test("returns authenticated false with null profile name", async () => {
-    mockProfileService.getAuthStatus = mock(() =>
-      Promise.resolve({ authenticated: false, profileName: null }),
-    );
-
-    const handler = new GetAuthStatusQueryHandler(mockProfileService);
-    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_AUTH_STATUS, {}));
-    expect(result.authenticated).toBe(false);
-    expect(result.profileName).toBeNull();
-  });
-});
-
-describe("ListModelsQueryHandler", () => {
-  let mockClient: IGeminiClientQueryService;
-
-  beforeEach(() => {
-    mockClient = {
-      listChats: mock(() => Promise.resolve([])),
-      fetchChat: mock(() => Promise.resolve([])),
-      listModels: mock(() => Promise.resolve([])),
-    };
-  });
-
-  test("has correct queryType", () => {
-    const handler = new ListModelsQueryHandler(mockClient);
-    expect(handler.queryType).toBe(QUERY_TYPES.LIST_MODELS);
-  });
-
-  test("returns models from gemini client", async () => {
-    const models = ["gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash"];
-    mockClient.listModels = mock(() => Promise.resolve(models));
-
-    const handler = new ListModelsQueryHandler(mockClient);
-    const result = await handler.handle(makeQuery(QUERY_TYPES.LIST_MODELS, {}));
-    expect(result.models).toEqual(models);
-  });
-});

package/tests/fixtures/auth-fixtures.ts

@@ -1,98 +0,0 @@
-import type { Cookie } from "../../src/core/types.ts";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { getTestConfigDir, createTestConfigDir } from "../setup.ts";
-
-const MOCK_COOKIE_DEFAULTS: Omit<Cookie, "name" | "value" | "expires"> = {
-  domain: ".google.com",
-  path: "/",
-  httpOnly: true,
-  secure: true,
-  sameSite: "None",
-};
-
-const FUTURE_EXPIRY = Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60;
-const PAST_EXPIRY = Math.floor(Date.now() / 1000) - 30 * 24 * 60 * 60;
-
-export interface MockCookiesOptions {
-  count?: number;
-  names?: string[];
-  expiry?: number;
-  values?: Record<string, string>;
-}
-
-export function createMockCookies(options: MockCookiesOptions = {}): Cookie[] {
-  const {
-    count = 4,
-    names,
-    expiry = FUTURE_EXPIRY,
-    values = {},
-  } = options;
-
-  const defaultNames = [
-    "__Secure-1PSID",
-    "__Secure-1PSIDTS",
-    "__Secure-1PSIDCC",
-    "NID",
-  ];
-
-  const cookieNames = names ?? defaultNames.slice(0, count);
-
-  return cookieNames.map((name) => ({
-    name,
-    value: values[name] ?? `mock-value-${name}`,
-    ...MOCK_COOKIE_DEFAULTS,
-    expires: expiry,
-  }));
-}
-
-export interface MockStorageStateOptions {
-  cookies?: Cookie[];
-  expiry?: number;
-}
-
-export function createMockStorageState(options: MockStorageStateOptions = {}): object {
-  const cookies = options.cookies ?? createMockCookies({ expiry: options.expiry ?? FUTURE_EXPIRY });
-  return { cookies };
-}
-
-export function createExpiredStorageState(): object {
-  const cookies = createMockCookies({ expiry: PAST_EXPIRY });
-  return { cookies };
-}
-
-export interface MockProfileDirOptions {
-  profileName?: string;
-  configDir?: string;
-  cookies?: Cookie[];
-  expired?: boolean;
-}
-
-export function mockProfileDir(options: MockProfileDirOptions = {}): string {
-  const {
-    profileName = "test-profile",
-    configDir,
-    expired = false,
-  } = options;
-
-  let dir: string;
-  try {
-    dir = configDir ?? getTestConfigDir();
-  } catch {
-    dir = createTestConfigDir();
-  }
-
-  const resolvedDir = resolve(dir);
-  const profileDir = join(resolvedDir, "profiles", profileName);
-  mkdirSync(profileDir, { recursive: true });
-
-  const state = expired
-    ? createExpiredStorageState()
-    : createMockStorageState({ cookies: options.cookies });
-
-  const filePath = join(profileDir, "storage_state.json");
-  writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
-
-  return profileDir;
-}

package/tests/fixtures/chat-fixtures.ts

@@ -1,87 +0,0 @@
-import type { ChatInfo, Message, Conversation } from "../../src/core/types.ts";
-
-export interface MockChatInfoOptions {
-  count?: number;
-  ids?: string[];
-  titles?: string[];
-  pinnedIndices?: number[];
-  baseTimestamp?: number;
-}
-
-export function createMockChatList(options: MockChatInfoOptions = {}): ChatInfo[] {
-  const {
-    count = 3,
-    ids,
-    titles,
-    pinnedIndices = [],
-    baseTimestamp = Date.now(),
-  } = options;
-
-  const defaultIds = ["conv-abc123", "conv-def456", "conv-ghi789", "conv-jkl012", "conv-mno345"];
-  const defaultTitles = [
-    "Chat about TypeScript",
-    "Pinned conversation",
-    "Bun runtime overview",
-    "Testing strategies",
-    "Deployment options",
-  ];
-
-  return Array.from({ length: count }, (_, i) => ({
-    id: ids?.[i] ?? defaultIds[i] ?? `conv-${i}`,
-    title: titles?.[i] ?? defaultTitles[i] ?? `Untitled chat ${i + 1}`,
-    isPinned: pinnedIndices.includes(i),
-    timestamp: baseTimestamp - i * 86400000,
-  }));
-}
-
-export interface MockMessageOptions {
-  count?: number;
-  conversationId?: string;
-  roles?: Array<"user" | "model">;
-  contents?: string[];
-}
-
-export function createMockMessageHistory(options: MockMessageOptions = {}): Message[] {
-  const {
-    count = 4,
-    conversationId,
-    roles,
-    contents,
-  } = options;
-
-  const defaultRoles: Array<"user" | "model"> = ["user", "model", "user", "model"];
-  const defaultContents = [
-    "Hello, Gemini!",
-    "Hi there! How can I help you today?",
-    "Tell me about TypeScript.",
-    "TypeScript is a typed superset of JavaScript.",
-  ];
-
-  return Array.from({ length: count }, (_, i) => ({
-    role: roles?.[i] ?? defaultRoles[i % defaultRoles.length],
-    content: contents?.[i] ?? defaultContents[i % defaultContents.length],
-    ...(conversationId ? { conversationId } : {}),
-  }));
-}
-
-export interface MockConversationOptions {
-  id?: string;
-  title?: string;
-  messages?: Message[];
-  messageCount?: number;
-}
-
-export function createMockConversation(options: MockConversationOptions = {}): Conversation {
-  const {
-    id = "conv-abc123",
-    title = "Chat about TypeScript",
-    messages,
-    messageCount = 4,
-  } = options;
-
-  return {
-    id,
-    title,
-    messages: messages ?? createMockMessageHistory({ count: messageCount, conversationId: id }),
-  };
-}