gemiterm 2.0.0

package/tests/unit/mediator.test.ts

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

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

@@ -0,0 +1,16 @@
+{
+  "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"]
+}