gemiterm 2.0.0 → 2.1.1

package/tests/infrastructure/cli-table.test.ts

@@ -1,107 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { renderTable, type ColumnDef } from "../../src/infrastructure/cli-table.ts";
-
-interface Row {
-  name: string;
-  age: number;
-}
-
-describe("renderTable", () => {
-  test("returns dim emptyMessage for empty rows", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [],
-      emptyMessage: "Nothing here",
-    });
-    expect(out).toContain("Nothing here");
-    expect(out).not.toContain("Name");
-  });
-
-  test("renders header row with column names", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [{ name: "Alice", age: 30 }],
-    });
-    expect(out).toContain("Name");
-    expect(out).toContain("Age");
-  });
-
-  test("renders data rows with cell values", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [
-        { name: "Alice", age: 30 },
-        { name: "Bob", age: 25 },
-      ],
-    });
-    expect(out).toContain("Alice");
-    expect(out).toContain("30");
-    expect(out).toContain("Bob");
-    expect(out).toContain("25");
-  });
-
-  test("includes Unicode box-drawing borders", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [{ name: "Alice", age: 30 }],
-    });
-    expect(out).toMatch(/[\u2500-\u257f]/);
-  });
-
-  test("appends footer when provided", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [{ name: "Alice", age: 30 }],
-      footer: "Total: 1",
-    });
-    expect(out).toContain("Total: 1");
-  });
-
-  test("does not crash with zero columns", () => {
-    const out = renderTable<Row>({
-      columns: [],
-      rows: [{ name: "Alice", age: 30 }],
-    });
-    expect(typeof out).toBe("string");
-  });
-
-  test("handles zero rows with no emptyMessage", () => {
-    const out = renderTable<Row>({
-      columns: [
-        { header: "Name", width: 10, cell: (r) => r.name },
-        { header: "Age", width: 5, cell: (r) => String(r.age) },
-      ],
-      rows: [],
-    });
-    expect(out).toContain("Name");
-  });
-
-  test("respects optional PROFILE-style spread-in column", () => {
-    const includeExtra = true;
-    const columns: ColumnDef<Row & { extra?: string }>[] = [
-      { header: "Name", width: 10, cell: (r) => r.name },
-      ...(includeExtra ? [{ header: "Extra", width: 8, cell: (r: Row & { extra?: string }) => r.extra ?? "" }] : []),
-    ];
-    const out = renderTable({
-      columns,
-      rows: [{ name: "Alice", age: 30, extra: "yes" }],
-    });
-    expect(out).toContain("Extra");
-    expect(out).toContain("yes");
-  });
-});

package/tests/infrastructure/formatters.test.ts

@@ -1,202 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  formatChatAsMarkdown,
-  formatChatAsJson,
-  formatProfileTable,
-  formatChatList,
-} from "../../src/infrastructure/formatters.ts";
-import type { Message, ChatInfo, ProfileStatus } from "../../src/core/types.ts";
-
-function makeMessages(): Message[] {
-  return [
-    { role: "user", content: "Hello, Gemini!" },
-    { role: "model", content: "Hi there! How can I help you today?" },
-    { role: "user", content: "Tell me about TypeScript." },
-    { role: "model", content: "TypeScript is a typed superset of JavaScript." },
-  ];
-}
-
-function makeChats(): ChatInfo[] {
-  return [
-    { id: "abc123", title: "Chat about TypeScript", isPinned: false, timestamp: Date.now() },
-    { id: "def456", title: "Pinned conversation", isPinned: true, timestamp: Date.now() - 86400000 },
-  ];
-}
-
-function makeStatuses(): ProfileStatus[] {
-  return [
-    {
-      name: "default",
-      exists: true,
-      isActive: true,
-      expiresAt: new Date(Date.now() + 7 * 86400000).toISOString(),
-      isDefault: true,
-    },
-    {
-      name: "expired-profile",
-      exists: true,
-      isActive: false,
-      expiresAt: new Date(Date.now() - 86400000).toISOString(),
-      isDefault: false,
-    },
-    {
-      name: "missing-cookies",
-      exists: true,
-      isActive: false,
-      expiresAt: null,
-      isDefault: false,
-    },
-  ];
-}
-
-describe("formatChatAsMarkdown", () => {
-  test("renders messages with proper markdown headers", () => {
-    const messages = makeMessages();
-    const result = formatChatAsMarkdown(messages, "Test Chat");
-
-    expect(result).toContain("# Test Chat");
-    expect(result).toContain("**You:**");
-    expect(result).toContain("**Gemini:**");
-    expect(result).toContain("Hello, Gemini!");
-    expect(result).toContain("TypeScript is a typed superset of JavaScript.");
-  });
-
-  test("includes separator lines between messages", () => {
-    const result = formatChatAsMarkdown(makeMessages(), "Title");
-    const separatorCount = (result.match(/^---$/gm) ?? []).length;
-    expect(separatorCount).toBe(4);
-  });
-
-  test("includes metadata when includeMetadata is true and conversationId provided", () => {
-    const result = formatChatAsMarkdown(
-      makeMessages(),
-      "Meta Chat",
-      "conv-xyz",
-      true,
-    );
-
-    expect(result).toContain("> Conversation ID: conv-xyz");
-    expect(result).toContain("> Messages: 4");
-    expect(result).toContain("> Exported:");
-  });
-
-  test("omits metadata when includeMetadata is false", () => {
-    const result = formatChatAsMarkdown(
-      makeMessages(),
-      "No Meta",
-      "conv-xyz",
-      false,
-    );
-
-    expect(result).not.toContain("> Conversation ID:");
-    expect(result).not.toContain("> Messages:");
-  });
-
-  test("handles empty messages array", () => {
-    const result = formatChatAsMarkdown([], "Empty Chat");
-    expect(result).toContain("# Empty Chat");
-    expect(result).not.toContain("**You:**");
-    expect(result).not.toContain("**Gemini:**");
-  });
-});
-
-describe("formatChatAsJson", () => {
-  test("returns valid JSON with conversationId and messages", () => {
-    const messages = makeMessages();
-    const result = formatChatAsJson(messages, "conv-123");
-
-    const parsed = JSON.parse(result);
-    expect(parsed.conversationId).toBe("conv-123");
-    expect(parsed.messages).toHaveLength(4);
-    expect(parsed.messages[0].role).toBe("user");
-    expect(parsed.messages[0].content).toBe("Hello, Gemini!");
-  });
-
-  test("handles empty messages array", () => {
-    const result = formatChatAsJson([], "conv-empty");
-    const parsed = JSON.parse(result);
-    expect(parsed.conversationId).toBe("conv-empty");
-    expect(parsed.messages).toEqual([]);
-  });
-});
-
-describe("formatProfileTable", () => {
-  test("renders profile statuses in table format", () => {
-    const statuses = makeStatuses();
-    const result = formatProfileTable(statuses);
-
-    expect(result).toContain("NAME");
-    expect(result).toContain("ACTIVE");
-    expect(result).toContain("EXPIRES");
-    expect(result).toContain("DEFAULT");
-    expect(result).toContain("default");
-    expect(result).toContain("expired-profile");
-  });
-
-  test("shows active checkmark for active profile", () => {
-    const statuses = makeStatuses();
-    const result = formatProfileTable(statuses);
-    expect(result).toContain("\u2713");
-  });
-
-  test("shows inactive X for inactive profile", () => {
-    const statuses = makeStatuses();
-    const result = formatProfileTable(statuses);
-    expect(result).toContain("\u2717");
-  });
-
-  test("shows default marker note", () => {
-    const result = formatProfileTable(makeStatuses());
-    expect(result).toContain("default profile");
-  });
-
-  test("returns message when no profiles exist", () => {
-    const result = formatProfileTable([]);
-    expect(result).toContain("No profiles found");
-  });
-
-  test("shows N/A for missing expiry date", () => {
-    const statuses: ProfileStatus[] = [
-      {
-        name: "no-expiry",
-        exists: true,
-        isActive: true,
-        expiresAt: null,
-        isDefault: false,
-      },
-    ];
-    const result = formatProfileTable(statuses);
-    expect(result).toContain("no-expiry");
-  });
-});
-
-describe("formatChatList", () => {
-  test("renders chat list in table format", () => {
-    const chats = makeChats();
-    const result = formatChatList(chats);
-
-    expect(result).toContain("ID");
-    expect(result).toContain("TITLE");
-    expect(result).toContain("DATE");
-    expect(result).toContain("abc123");
-    expect(result).toContain("Chat about TypeScript");
-  });
-
-  test("shows total count footer", () => {
-    const result = formatChatList(makeChats());
-    expect(result).toContain("Total: 2 conversations");
-  });
-
-  test("shows singular when only one chat", () => {
-    const chats: ChatInfo[] = [
-      { id: "solo", title: "Solo chat", isPinned: false, timestamp: Date.now() },
-    ];
-    const result = formatChatList(chats);
-    expect(result).toContain("Total: 1 conversation");
-  });
-
-  test("returns message when no chats exist", () => {
-    const result = formatChatList([]);
-    expect(result).toContain("No conversations found");
-  });
-});

package/tests/infrastructure/io.test.ts

@@ -1,197 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  ensureDir,
-  existsFile,
-  readTextFile,
-  safeReadTextFile,
-  writeTextFile,
-  readJsonFile,
-  writeJsonFile,
-  removeDir,
-  renameDir,
-  isDirectory,
-  listSubdirectories,
-  IOError,
-} from "../../src/infrastructure/io.ts";
-
-const TEST_ROOT = join(tmpdir(), `gemiterm-io-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-
-beforeEach(() => {
-  ensureDir(TEST_ROOT);
-});
-
-afterEach(() => {
-  try {
-    removeDir(TEST_ROOT);
-  } catch {
-    // ignore
-  }
-});
-
-describe("IOError", () => {
-  test("has correct name and message", () => {
-    const err = new IOError("boom");
-    expect(err.name).toBe("IOError");
-    expect(err.message).toBe("boom");
-    expect(err.cause).toBeUndefined();
-  });
-
-  test("preserves cause", () => {
-    const cause = new Error("underlying");
-    const err = new IOError("wrapper", cause);
-    expect(err.cause).toBe(cause);
-  });
-});
-
-describe("ensureDir", () => {
-  test("creates a directory that does not exist", () => {
-    const dir = join(TEST_ROOT, "new-dir");
-    expect(existsFile(dir)).toBe(false);
-    ensureDir(dir);
-    expect(existsFile(dir)).toBe(true);
-    expect(isDirectory(dir)).toBe(true);
-  });
-
-  test("creates nested directories recursively", () => {
-    const dir = join(TEST_ROOT, "a", "b", "c");
-    expect(existsFile(dir)).toBe(false);
-    ensureDir(dir);
-    expect(isDirectory(dir)).toBe(true);
-    expect(isDirectory(join(TEST_ROOT, "a", "b"))).toBe(true);
-    expect(isDirectory(join(TEST_ROOT, "a"))).toBe(true);
-  });
-
-  test("is a no-op on an existing directory", () => {
-    ensureDir(TEST_ROOT);
-    expect(() => ensureDir(TEST_ROOT)).not.toThrow();
-  });
-});
-
-describe("existsFile", () => {
-  test("returns true for an existing file", () => {
-    const file = join(TEST_ROOT, "marker.txt");
-    ensureDir(TEST_ROOT);
-    writeTextFile(file, "x");
-    expect(existsFile(file)).toBe(true);
-  });
-
-  test("returns false for a missing file", () => {
-    expect(existsFile(join(TEST_ROOT, "nope.txt"))).toBe(false);
-  });
-});
-
-describe("readTextFile", () => {
-  test("reads an existing file as UTF-8", () => {
-    const file = join(TEST_ROOT, "read.txt");
-    writeTextFile(file, "hello");
-    expect(readTextFile(file)).toBe("hello");
-  });
-
-  test("throws IOError on a missing file", () => {
-    expect(() => readTextFile(join(TEST_ROOT, "nope.txt"))).toThrow(IOError);
-  });
-});
-
-describe("safeReadTextFile", () => {
-  test("returns the content of an existing file", () => {
-    const file = join(TEST_ROOT, "safe.txt");
-    writeTextFile(file, "content");
-    expect(safeReadTextFile(file)).toBe("content");
-  });
-
-  test("returns the empty string on a missing file", () => {
-    expect(safeReadTextFile(join(TEST_ROOT, "nope.txt"))).toBe("");
-  });
-});
-
-describe("writeTextFile", () => {
-  test("writes a new file", () => {
-    const file = join(TEST_ROOT, "out.txt");
-    writeTextFile(file, "data");
-    expect(existsFile(file)).toBe(true);
-    expect(readTextFile(file)).toBe("data");
-  });
-
-  test("creates nested directories that do not exist", () => {
-    const file = join(TEST_ROOT, "nested", "deep", "out.txt");
-    writeTextFile(file, "data");
-    expect(readTextFile(file)).toBe("data");
-  });
-});
-
-describe("readJsonFile and writeJsonFile", () => {
-  test("round-trips a JSON object", () => {
-    const file = join(TEST_ROOT, "obj.json");
-    const original = { a: 1, b: ["x", "y"], c: { nested: true } };
-    writeJsonFile(file, original);
-    const read = readJsonFile<typeof original>(file);
-    expect(read).toEqual(original);
-  });
-
-  test("readJsonFile throws on missing file", () => {
-    expect(() => readJsonFile(join(TEST_ROOT, "missing.json"))).toThrow(IOError);
-  });
-});
-
-describe("removeDir", () => {
-  test("removes a directory recursively", () => {
-    const dir = join(TEST_ROOT, "rm");
-    ensureDir(dir);
-    writeTextFile(join(dir, "f.txt"), "x");
-    expect(existsFile(dir)).toBe(true);
-    removeDir(dir);
-    expect(existsFile(dir)).toBe(false);
-  });
-
-  test("is a no-op on a missing path", () => {
-    expect(() => removeDir(join(TEST_ROOT, "nope"))).not.toThrow();
-  });
-});
-
-describe("renameDir", () => {
-  test("renames a directory", () => {
-    const src = join(TEST_ROOT, "src");
-    const dest = join(TEST_ROOT, "dest");
-    ensureDir(src);
-    expect(isDirectory(src)).toBe(true);
-    renameDir(src, dest);
-    expect(isDirectory(src)).toBe(false);
-    expect(isDirectory(dest)).toBe(true);
-  });
-
-  test("throws when source is missing", () => {
-    expect(() => renameDir(join(TEST_ROOT, "nope"), join(TEST_ROOT, "dest"))).toThrow(IOError);
-  });
-});
-
-describe("isDirectory", () => {
-  test("returns true for a directory", () => {
-    expect(isDirectory(TEST_ROOT)).toBe(true);
-  });
-
-  test("returns false for a file", () => {
-    const file = join(TEST_ROOT, "f.txt");
-    writeTextFile(file, "x");
-    expect(isDirectory(file)).toBe(false);
-  });
-
-  test("returns false for a missing path", () => {
-    expect(isDirectory(join(TEST_ROOT, "nope"))).toBe(false);
-  });
-});
-
-describe("listSubdirectories", () => {
-  test("returns only subdirectory names", () => {
-    ensureDir(join(TEST_ROOT, "a"));
-    ensureDir(join(TEST_ROOT, "b"));
-    writeTextFile(join(TEST_ROOT, "not-a-dir.txt"), "x");
-    const subs = listSubdirectories(TEST_ROOT).sort();
-    expect(subs).toEqual(["a", "b"]);
-  });
-
-  test("returns an empty array for a missing path", () => {
-    expect(listSubdirectories(join(TEST_ROOT, "nope"))).toEqual([]);
-  });
-});

package/tests/infrastructure/logger.test.ts

@@ -1,74 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
-import { Logger } from "../../src/infrastructure/logger.ts";
-
-describe("Logger", () => {
-  let stderrSpy: ReturnType<typeof spyOn>;
-
-  beforeEach(() => {
-    stderrSpy = spyOn(process.stderr, "write").mockImplementation(() => true);
-    Logger.setVerbose(false);
-  });
-
-  afterEach(() => {
-    stderrSpy.mockRestore();
-  });
-
-  test("info writes to stderr with correct format", () => {
-    const logger = new Logger("test-module");
-    logger.info("hello world");
-
-    expect(stderrSpy).toHaveBeenCalledTimes(1);
-    const output = stderrSpy.mock.calls[0][0] as string;
-    expect(output).toMatch(/^\[\d{4}-\d{2}-\d{2}T/);
-    expect(output).toContain("[INFO] [test-module] hello world");
-  });
-
-  test("warn writes to stderr with WARN level", () => {
-    const logger = new Logger("cli");
-    logger.warn("something happened");
-
-    const output = stderrSpy.mock.calls[0][0] as string;
-    expect(output).toContain("[WARN] [cli] something happened");
-  });
-
-  test("error writes to stderr with ERROR level", () => {
-    const logger = new Logger("auth");
-    logger.error("failed");
-
-    const output = stderrSpy.mock.calls[0][0] as string;
-    expect(output).toContain("[ERROR] [auth] failed");
-  });
-
-  test("debug is silent when verbose is off", () => {
-    const logger = new Logger("test");
-    logger.debug("should not appear");
-
-    expect(stderrSpy).toHaveBeenCalledTimes(0);
-  });
-
-  test("debug writes to stderr when verbose is on", () => {
-    Logger.setVerbose(true);
-    const logger = new Logger("test");
-    logger.debug("verbose message");
-
-    expect(stderrSpy).toHaveBeenCalledTimes(1);
-    const output = stderrSpy.mock.calls[0][0] as string;
-    expect(output).toContain("[DEBUG] [test] verbose message");
-  });
-
-  test("extra args are appended to message", () => {
-    const logger = new Logger("svc");
-    logger.info("result", 42, "extra");
-
-    const output = stderrSpy.mock.calls[0][0] as string;
-    expect(output).toContain("[svc] result 42 extra");
-  });
-
-  test("isVerbose returns current verbose state", () => {
-    expect(Logger.isVerbose()).toBe(false);
-    Logger.setVerbose(true);
-    expect(Logger.isVerbose()).toBe(true);
-    Logger.setVerbose(false);
-    expect(Logger.isVerbose()).toBe(false);
-  });
-});