gemiterm 2.0.0 → 2.1.1

package/tests/unit/mediator.test.ts

@@ -1,152 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import {
-  Mediator,
-  type QueryHandler,
-  type CommandHandler,
-  type Query,
-  type Command,
-} from "../../src/core/mediator.ts";
-
-describe("Mediator", () => {
-  let mediator: Mediator;
-
-  beforeEach(() => {
-    mediator = new Mediator();
-  });
-
-  describe("registerQueryHandler and send (queries)", () => {
-    test("resolves a query via a registered handler", async () => {
-      const handler: QueryHandler<string, number> = {
-        queryType: "GetLength",
-        handle(query: Query<string>) {
-          return Promise.resolve(query.payload.length);
-        },
-      };
-
-      mediator.registerQueryHandler(handler);
-
-      const result = await mediator.send<number>({
-        type: "GetLength",
-        payload: "hello",
-      });
-
-      expect(result).toBe(5);
-    });
-
-    test("throws if two handlers are registered for the same query type", () => {
-      const handlerA: QueryHandler<void, void> = {
-        queryType: "Duplicate",
-        handle() {
-          return Promise.resolve();
-        },
-      };
-      const handlerB: QueryHandler<void, void> = {
-        queryType: "Duplicate",
-        handle() {
-          return Promise.resolve();
-        },
-      };
-
-      mediator.registerQueryHandler(handlerA);
-
-      expect(() => mediator.registerQueryHandler(handlerB)).toThrow(
-        "Query handler already registered for type: Duplicate",
-      );
-    });
-
-    test("passes the full query object to the handler", async () => {
-      let received: Query<{ key: string }> | undefined;
-      const handler: QueryHandler<{ key: string }, string> = {
-        queryType: "Inspect",
-        handle(query) {
-          received = query;
-          return Promise.resolve("ok");
-        },
-      };
-
-      mediator.registerQueryHandler(handler);
-
-      await mediator.send({ type: "Inspect", payload: { key: "val" } });
-
-      expect(received).toBeDefined();
-      expect(received!.type).toBe("Inspect");
-      expect(received!.payload).toEqual({ key: "val" });
-    });
-  });
-
-  describe("registerCommandHandler and send (commands)", () => {
-    test("resolves a command via a registered handler", async () => {
-      const handler: CommandHandler<string, string> = {
-        commandType: "Echo",
-        handle(cmd: Command<string>) {
-          return Promise.resolve(cmd.payload);
-        },
-      };
-
-      mediator.registerCommandHandler(handler);
-
-      const result = await mediator.send<string>({
-        type: "Echo",
-        payload: "hello world",
-      });
-
-      expect(result).toBe("hello world");
-    });
-
-    test("throws if two handlers are registered for the same command type", () => {
-      const handlerA: CommandHandler<void, void> = {
-        commandType: "Duplicate",
-        handle() {
-          return Promise.resolve();
-        },
-      };
-      const handlerB: CommandHandler<void, void> = {
-        commandType: "Duplicate",
-        handle() {
-          return Promise.resolve();
-        },
-      };
-
-      mediator.registerCommandHandler(handlerA);
-
-      expect(() => mediator.registerCommandHandler(handlerB)).toThrow(
-        "Command handler already registered for type: Duplicate",
-      );
-    });
-  });
-
-  describe("unknown message type", () => {
-    test("throws when sending a message with no registered handler", async () => {
-      await expect(
-        mediator.send({ type: "NobodyHandlesMe", payload: null }),
-      ).rejects.toThrow(
-        "No handler registered for message type: NobodyHandlesMe",
-      );
-    });
-
-    test("does not mix query and command handlers", async () => {
-      mediator.registerQueryHandler<void, string>({
-        queryType: "OnlyQuery",
-        handle() {
-          return Promise.resolve("query-result");
-        },
-      });
-
-      await expect(
-        mediator.send({ type: "OnlyQuery", payload: undefined }),
-      ).resolves.toBe("query-result");
-
-      const fresh = new Mediator();
-      fresh.registerCommandHandler<void, string>({
-        commandType: "OnlyCommand",
-        handle() {
-          return Promise.resolve("command-result");
-        },
-      });
-
-      await expect(
-        fresh.send({ type: "OnlyCommand", payload: undefined }),
-      ).resolves.toBe("command-result");
-    });
-  });
-});

package/tests/unit/path-utils.test.ts

@@ -1,289 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
-import { join, resolve } from "node:path";
-import * as os from "node:os";
-import * as fs from "node:fs";
-import {
-  resolvePath,
-  getConfigDir,
-  getProfilesDir,
-  getProfilePath,
-  getProfileDir,
-  getDefaultProfileMarkerPath,
-  isWSL,
-  getProjectRoot,
-  getPackageJson,
-  STORAGE_STATE_FILE,
-  PROFILES_DIR,
-  DEFAULT_PROFILE_MARKER,
-} from "../../src/infrastructure/path-utils.ts";
-
-describe("path-utils", () => {
-  describe("constants", () => {
-    test("STORAGE_STATE_FILE is storage_state.json", () => {
-      expect(STORAGE_STATE_FILE).toBe("storage_state.json");
-    });
-
-    test("PROFILES_DIR is profiles", () => {
-      expect(PROFILES_DIR).toBe("profiles");
-    });
-
-    test("DEFAULT_PROFILE_MARKER is .default", () => {
-      expect(DEFAULT_PROFILE_MARKER).toBe(".default");
-    });
-  });
-
-  describe("resolvePath", () => {
-    test("joins and resolves path segments", () => {
-      const result = resolvePath("foo", "bar", "baz.txt");
-      expect(result).toBe(resolve(join("foo", "bar", "baz.txt")));
-    });
-
-    test("resolves relative paths to absolute", () => {
-      const result = resolvePath("a", "b");
-      expect(result).toBe(resolve(join("a", "b")));
-    });
-
-    test("handles single segment", () => {
-      const result = resolvePath("single");
-      expect(result).toBe(resolve("single"));
-    });
-
-    test("normalizes paths with .. and .", () => {
-      const result = resolvePath("foo", "..", "bar");
-      expect(result).toBe(resolve(join("foo", "..", "bar")));
-    });
-
-    test("handles empty input", () => {
-      const result = resolvePath();
-      expect(result).toBe(resolve(join()));
-    });
-  });
-
-  describe("getConfigDir", () => {
-    let originalConfigDir: string | undefined;
-    let originalAppData: string | undefined;
-
-    beforeEach(() => {
-      originalConfigDir = process.env.GEMITERM_CONFIG_DIR;
-      originalAppData = process.env.APPDATA;
-      delete process.env.GEMITERM_CONFIG_DIR;
-    });
-
-    afterEach(() => {
-      if (originalConfigDir !== undefined) {
-        process.env.GEMITERM_CONFIG_DIR = originalConfigDir;
-      } else {
-        delete process.env.GEMITERM_CONFIG_DIR;
-      }
-      if (originalAppData !== undefined) {
-        process.env.APPDATA = originalAppData;
-      } else {
-        delete process.env.APPDATA;
-      }
-    });
-
-    test("returns GEMITERM_CONFIG_DIR env override when set", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/my-custom-config";
-      expect(getConfigDir()).toBe("/tmp/my-custom-config");
-    });
-
-    test("on win32 with APPDATA, returns APPDATA/gemiterm", () => {
-      const platformSpy = spyOn(os, "platform").mockReturnValue("win32");
-      process.env.APPDATA = "C:\\Users\\test\\AppData\\Roaming";
-      expect(getConfigDir()).toBe(join("C:\\Users\\test\\AppData\\Roaming", "gemiterm"));
-      platformSpy.mockRestore();
-    });
-
-    test("on win32 without APPDATA, falls back to homedir/gemiterm", () => {
-      const platformSpy = spyOn(os, "platform").mockReturnValue("win32");
-      delete process.env.APPDATA;
-      expect(getConfigDir()).toBe(join(os.homedir(), "gemiterm"));
-      platformSpy.mockRestore();
-    });
-
-    test("on linux, returns homedir/gemiterm", () => {
-      const platformSpy = spyOn(os, "platform").mockReturnValue("linux");
-      delete process.env.APPDATA;
-      expect(getConfigDir()).toBe(join(os.homedir(), "gemiterm"));
-      platformSpy.mockRestore();
-    });
-
-    test("on darwin, returns homedir/gemiterm", () => {
-      const platformSpy = spyOn(os, "platform").mockReturnValue("darwin");
-      expect(getConfigDir()).toBe(join(os.homedir(), "gemiterm"));
-      platformSpy.mockRestore();
-    });
-
-    test("env override takes precedence over platform-specific path", () => {
-      const platformSpy = spyOn(os, "platform").mockReturnValue("win32");
-      process.env.GEMITERM_CONFIG_DIR = "/override/path";
-      process.env.APPDATA = "C:\\AppData";
-      expect(getConfigDir()).toBe("/override/path");
-      platformSpy.mockRestore();
-    });
-  });
-
-  describe("getProfilesDir", () => {
-    let originalConfigDir: string | undefined;
-
-    beforeEach(() => {
-      originalConfigDir = process.env.GEMITERM_CONFIG_DIR;
-    });
-
-    afterEach(() => {
-      if (originalConfigDir !== undefined) {
-        process.env.GEMITERM_CONFIG_DIR = originalConfigDir;
-      } else {
-        delete process.env.GEMITERM_CONFIG_DIR;
-      }
-    });
-
-    test("returns config dir + profiles", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/gemiterm";
-      expect(getProfilesDir()).toBe(join("/tmp/gemiterm", PROFILES_DIR));
-    });
-  });
-
-  describe("getProfilePath", () => {
-    let originalConfigDir: string | undefined;
-
-    beforeEach(() => {
-      originalConfigDir = process.env.GEMITERM_CONFIG_DIR;
-    });
-
-    afterEach(() => {
-      if (originalConfigDir !== undefined) {
-        process.env.GEMITERM_CONFIG_DIR = originalConfigDir;
-      } else {
-        delete process.env.GEMITERM_CONFIG_DIR;
-      }
-    });
-
-    test("returns profiles/<name>/storage_state.json", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/gemiterm";
-      expect(getProfilePath("default")).toBe(
-        join("/tmp/gemiterm", PROFILES_DIR, "default", STORAGE_STATE_FILE),
-      );
-    });
-
-    test("handles profile names with special characters", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/gemiterm";
-      expect(getProfilePath("my-profile")).toBe(
-        join("/tmp/gemiterm", PROFILES_DIR, "my-profile", STORAGE_STATE_FILE),
-      );
-    });
-  });
-
-  describe("getProfileDir", () => {
-    let originalConfigDir: string | undefined;
-
-    beforeEach(() => {
-      originalConfigDir = process.env.GEMITERM_CONFIG_DIR;
-    });
-
-    afterEach(() => {
-      if (originalConfigDir !== undefined) {
-        process.env.GEMITERM_CONFIG_DIR = originalConfigDir;
-      } else {
-        delete process.env.GEMITERM_CONFIG_DIR;
-      }
-    });
-
-    test("returns profiles/<name>", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/gemiterm";
-      expect(getProfileDir("work")).toBe(join("/tmp/gemiterm", PROFILES_DIR, "work"));
-    });
-  });
-
-  describe("getDefaultProfileMarkerPath", () => {
-    let originalConfigDir: string | undefined;
-
-    beforeEach(() => {
-      originalConfigDir = process.env.GEMITERM_CONFIG_DIR;
-    });
-
-    afterEach(() => {
-      if (originalConfigDir !== undefined) {
-        process.env.GEMITERM_CONFIG_DIR = originalConfigDir;
-      } else {
-        delete process.env.GEMITERM_CONFIG_DIR;
-      }
-    });
-
-    test("returns profiles/.default", () => {
-      process.env.GEMITERM_CONFIG_DIR = "/tmp/gemiterm";
-      expect(getDefaultProfileMarkerPath()).toBe(
-        join("/tmp/gemiterm", PROFILES_DIR, DEFAULT_PROFILE_MARKER),
-      );
-    });
-  });
-
-  describe("isWSL", () => {
-    let originalPlatform: NodeJS.Platform;
-    let originalWslDistro: string | undefined;
-
-    beforeEach(() => {
-      originalPlatform = process.platform;
-      originalWslDistro = process.env.WSL_DISTRO_NAME;
-    });
-
-    afterEach(() => {
-      Object.defineProperty(process, "platform", { value: originalPlatform, configurable: true });
-      if (originalWslDistro !== undefined) {
-        process.env.WSL_DISTRO_NAME = originalWslDistro;
-      } else {
-        delete process.env.WSL_DISTRO_NAME;
-      }
-    });
-
-    test("returns false on Windows", () => {
-      Object.defineProperty(process, "platform", { value: "win32", configurable: true });
-      delete process.env.WSL_DISTRO_NAME;
-      expect(isWSL()).toBe(false);
-    });
-
-    test("returns false on macOS", () => {
-      Object.defineProperty(process, "platform", { value: "darwin", configurable: true });
-      delete process.env.WSL_DISTRO_NAME;
-      expect(isWSL()).toBe(false);
-    });
-
-    test("returns true on Linux when WSL_DISTRO_NAME is set and non-empty", () => {
-      Object.defineProperty(process, "platform", { value: "linux", configurable: true });
-      process.env.WSL_DISTRO_NAME = "Ubuntu";
-      expect(isWSL()).toBe(true);
-    });
-
-    test("returns false on Linux when WSL_DISTRO_NAME is unset and no /proc/version marker", () => {
-      Object.defineProperty(process, "platform", { value: "linux", configurable: true });
-      delete process.env.WSL_DISTRO_NAME;
-      const existsSpy = spyOn(fs, "existsSync").mockReturnValue(false);
-      try {
-        expect(isWSL()).toBe(false);
-      } finally {
-        existsSpy.mockRestore();
-      }
-    });
-  });
-
-  describe("getProjectRoot", () => {
-    test("returns the repo root when called from a file under the repo", () => {
-      const root = getProjectRoot(import.meta.url);
-      expect(root).toBeTruthy();
-      expect(fs.existsSync(join(root, "package.json"))).toBe(true);
-    });
-
-    test("is idempotent — multiple calls return the same path", () => {
-      const a = getProjectRoot(import.meta.url);
-      const b = getProjectRoot(import.meta.url);
-      expect(a).toBe(b);
-    });
-  });
-
-  describe("getPackageJson", () => {
-    test("returns the parsed package.json with name and version", () => {
-      const pkg = getPackageJson(import.meta.url);
-      expect(pkg.name).toBe("gemiterm");
-    });
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "allowImportingTsExtensions": true,
-    "types": ["bun"],
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}