gemiterm 2.0.0 → 2.1.1

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

@@ -1,220 +0,0 @@
-import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { AuthCommand } from "../../src/cli/commands/auth-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("AuthCommand", () => {
-  let command: AuthCommand;
-  let context: CliCommandContext;
-  let listSpy: ReturnType<typeof spyOn>;
-  let defaultProfileSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    command = new AuthCommand();
-    context = { verbose: false, mediator: new Mediator() };
-    listSpy = spyOn(configModule, "listProfiles").mockReturnValue([]);
-    defaultProfileSpy = spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
-  });
-
-  afterEach(() => {
-    mock.restore();
-    listSpy.mockRestore();
-    defaultProfileSpy.mockRestore();
-  });
-
-  test("has correct name and description", () => {
-    expect(command.name).toBe("auth");
-    expect(command.description).toBe("Authenticate with Google Gemini");
-  });
-
-  describe("execute", () => {
-    test("authenticates with default profile when no profiles exist", async () => {
-      listSpy.mockReturnValue([]);
-
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "default",
-        expect.anything(),
-        true,
-      );
-    });
-
-    test("authenticates directly when only one profile exists", async () => {
-      listSpy.mockReturnValue(["my-profile"]);
-
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "my-profile",
-        expect.anything(),
-        false,
-      );
-    });
-
-    test("shows profile menu when multiple profiles exist", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const menuSpy = spyOn(command as any, "showProfileMenu").mockResolvedValue(null);
-      await command.execute([], context);
-
-      expect(menuSpy).toHaveBeenCalled();
-    });
-
-    test("authenticates selected profile from menu", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const menuSpy = spyOn(command as any, "showProfileMenu").mockResolvedValue({
-        type: "auth",
-        profileName: "p2",
-      });
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-
-      await command.execute([], context);
-
-      expect(authSpy).toHaveBeenCalledWith(
-        expect.anything(),
-        "p2",
-        expect.anything(),
-        false,
-      );
-    });
-
-    test("exits when X is selected in profile menu", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const promptSpy = spyOn(command as any, "promptInput").mockResolvedValue("X");
-      const logSpy = spyOn(console, "log").mockImplementation(() => {});
-
-      await command.execute([], context);
-
-      expect(promptSpy).toHaveBeenCalledWith("Select an option");
-      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Continuing with current default"));
-      logSpy.mockRestore();
-    });
-
-    test("throws on invalid profile name when adding", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
-        (prompt: string) => {
-          if (prompt.includes("Select")) return Promise.resolve("A");
-          if (prompt.includes("Enter profile name")) return Promise.resolve("bad name!!");
-          return Promise.resolve("");
-        },
-      );
-
-      await expect(command.execute([], context)).rejects.toThrow("invalid characters");
-    });
-
-    test("throws when deleting nonexistent profile", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
-        (prompt: string) => {
-          if (prompt.includes("Select")) return Promise.resolve("D");
-          if (prompt.includes("Enter profile name to delete")) return Promise.resolve("ghost");
-          return Promise.resolve("");
-        },
-      );
-
-      await expect(command.execute([], context)).rejects.toThrow("does not exist");
-    });
-
-    test("cancels deletion when user answers no", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
-        (prompt: string) => {
-          if (prompt.includes("Select")) return Promise.resolve("D");
-          if (prompt.includes("Enter profile name to delete")) return Promise.resolve("p1");
-          if (prompt.includes("Delete profile")) return Promise.resolve("n");
-          return Promise.resolve("");
-        },
-      );
-
-      await command.execute([], context);
-    });
-
-    test("renames profile and authenticates with new name", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const authSpy = spyOn(command as any, "authenticateWithProfile").mockResolvedValue(undefined);
-      const mockRename = mock(() => {});
-
-      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
-      const origProto = ProfileManager.prototype.rename;
-      ProfileManager.prototype.rename = mockRename;
-
-      try {
-        const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
-          (prompt: string) => {
-            if (prompt.includes("Select")) return Promise.resolve("R");
-            if (prompt.includes("current profile name")) return Promise.resolve("p1");
-            if (prompt.includes("new profile name")) return Promise.resolve("p1-new");
-            return Promise.resolve("");
-          },
-        );
-
-        await command.execute([], context);
-
-        expect(mockRename).toHaveBeenCalledWith("p1", "p1-new");
-        expect(authSpy).toHaveBeenCalledWith(
-          expect.anything(),
-          "p1-new",
-          expect.anything(),
-          false,
-        );
-      } finally {
-        ProfileManager.prototype.rename = origProto;
-      }
-    });
-
-    test("set default for a profile", async () => {
-      listSpy.mockReturnValue(["p1", "p2"]);
-
-      const logSpy = spyOn(console, "log").mockImplementation(() => {});
-      const setDefaultSpy = spyOn(configModule, "setDefaultProfileName").mockImplementation(() => {});
-      const mockSetDefault = mock(() => {});
-
-      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
-      const origProto = ProfileManager.prototype.setDefault;
-      ProfileManager.prototype.setDefault = mockSetDefault;
-
-      try {
-        const promptSpy = spyOn(command as any, "promptInput").mockImplementation(
-          (prompt: string) => {
-            if (prompt.includes("Select")) return Promise.resolve("S");
-            if (prompt.includes("Enter profile name to set as default")) return Promise.resolve("p2");
-            return Promise.resolve("");
-          },
-        );
-
-        await command.execute([], context);
-
-        expect(mockSetDefault).toHaveBeenCalledWith("p2");
-        expect(setDefaultSpy).toHaveBeenCalledWith("p2");
-      } finally {
-        ProfileManager.prototype.setDefault = origProto;
-        logSpy.mockRestore();
-      }
-    });
-  });
-
-  describe("showProfileMenu", () => {
-    test("returns null for unknown option", async () => {
-      const promptSpy = spyOn(command as any, "promptInput").mockResolvedValue("Z");
-
-      const result = await (command as any).showProfileMenu(["p1"], {
-        getStatus: () => ({ name: "p1", exists: true, isActive: true, expiresAt: null, isDefault: true }),
-      } as any);
-
-      expect(result).toBeNull();
-    });
-  });
-});

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

@@ -1,67 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

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