gitforest 0.1.0

package/test/unit/types/commands.test.ts

@@ -0,0 +1,220 @@
+import { describe, test, expect } from "bun:test";
+import { CommandConfigSchema, RESERVED_KEYS, GitforestConfigSchema } from "../../../src/types/index.ts";
+
+describe("CommandConfigSchema", () => {
+  test("validates a valid command config", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Open Editor",
+      key: "e",
+      command: "code .",
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.name).toBe("Open Editor");
+      expect(result.data.key).toBe("e");
+      expect(result.data.command).toBe("code .");
+      expect(result.data.confirm).toBe(false);
+      expect(result.data.background).toBe(false);
+    }
+  });
+
+  test("validates command with optional fields", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Run Build",
+      key: "b",
+      command: "bun run build",
+      confirm: true,
+      background: true,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.confirm).toBe(true);
+      expect(result.data.background).toBe(true);
+    }
+  });
+
+  test("rejects empty name", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "",
+      key: "e",
+      command: "code .",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects empty command", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "e",
+      command: "",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects multi-character key", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "ab",
+      command: "echo test",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects reserved key 'j' (navigation)", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "j",
+      command: "echo test",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects reserved key 'q' (quit)", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "q",
+      command: "echo test",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects reserved key 'p' (push)", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "p",
+      command: "echo test",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects reserved key '1' (quick filter)", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "1",
+      command: "echo test",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("accepts non-reserved key 'e'", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Editor",
+      key: "e",
+      command: "code .",
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  test("accepts non-reserved key 't'", () => {
+    const result = CommandConfigSchema.safeParse({
+      name: "Test",
+      key: "t",
+      command: "bun test",
+    });
+
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("RESERVED_KEYS", () => {
+  test("contains navigation keys", () => {
+    expect(RESERVED_KEYS.has("j")).toBe(true);
+    expect(RESERVED_KEYS.has("k")).toBe(true);
+    expect(RESERVED_KEYS.has("g")).toBe(true);
+    expect(RESERVED_KEYS.has("G")).toBe(true);
+  });
+
+  test("contains selection keys", () => {
+    expect(RESERVED_KEYS.has(" ")).toBe(true);
+    expect(RESERVED_KEYS.has("a")).toBe(true);
+  });
+
+  test("contains git operation keys", () => {
+    expect(RESERVED_KEYS.has("p")).toBe(true);
+    expect(RESERVED_KEYS.has("P")).toBe(true);
+    expect(RESERVED_KEYS.has("f")).toBe(true);
+    expect(RESERVED_KEYS.has("i")).toBe(true);
+  });
+
+  test("contains github operation keys", () => {
+    expect(RESERVED_KEYS.has("c")).toBe(true);
+    expect(RESERVED_KEYS.has("C")).toBe(true);
+    expect(RESERVED_KEYS.has("A")).toBe(true);
+    expect(RESERVED_KEYS.has("D")).toBe(true);
+  });
+
+  test("contains quick filter number keys", () => {
+    for (let i = 0; i <= 9; i++) {
+      expect(RESERVED_KEYS.has(String(i))).toBe(true);
+    }
+  });
+
+  test("contains command palette trigger key", () => {
+    expect(RESERVED_KEYS.has("x")).toBe(true);
+  });
+});
+
+describe("GitforestConfigSchema commands", () => {
+  const baseConfig = {
+    directories: [{ path: "~/projects", maxDepth: 2 }],
+  };
+
+  test("accepts config without commands", () => {
+    const result = GitforestConfigSchema.safeParse(baseConfig);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.commands).toEqual([]);
+    }
+  });
+
+  test("accepts config with valid commands", () => {
+    const result = GitforestConfigSchema.safeParse({
+      ...baseConfig,
+      commands: [
+        { name: "Editor", key: "e", command: "code ." },
+        { name: "Tests", key: "t", command: "bun test" },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.commands).toHaveLength(2);
+    }
+  });
+
+  test("rejects duplicate command keys", () => {
+    const result = GitforestConfigSchema.safeParse({
+      ...baseConfig,
+      commands: [
+        { name: "Editor 1", key: "e", command: "code ." },
+        { name: "Editor 2", key: "e", command: "vim ." },
+      ],
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("accepts different keys for different commands", () => {
+    const result = GitforestConfigSchema.safeParse({
+      ...baseConfig,
+      commands: [
+        { name: "Editor", key: "e", command: "code ." },
+        { name: "Terminal", key: "T", command: "open -a Terminal ." },
+        { name: "Build", key: "b", command: "bun run build" },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+  });
+});

package/test/unit/types/schema.test.ts

@@ -0,0 +1,179 @@
+import { describe, test, expect } from "bun:test";
+import { GitforestConfigSchema, DirectoryConfigSchema } from "../../../src/types/index.ts";
+
+describe("DirectoryConfigSchema", () => {
+  test("validates valid directory config", () => {
+    const result = DirectoryConfigSchema.safeParse({
+      path: "~/projects",
+      maxDepth: 2,
+      label: "Projects",
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.path).toBe("~/projects");
+      expect(result.data.maxDepth).toBe(2);
+      expect(result.data.label).toBe("Projects");
+    }
+  });
+
+  test("uses default maxDepth when not provided", () => {
+    const result = DirectoryConfigSchema.safeParse({
+      path: "~/projects",
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.maxDepth).toBe(2);
+    }
+  });
+
+  test("rejects empty path", () => {
+    const result = DirectoryConfigSchema.safeParse({
+      path: "",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("label is optional", () => {
+    const result = DirectoryConfigSchema.safeParse({
+      path: "~/projects",
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.label).toBeUndefined();
+    }
+  });
+});
+
+describe("GitforestConfigSchema", () => {
+  test("validates minimal valid config", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  test("applies default values", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.scan.ignore).toContain("node_modules");
+      expect(result.data.scan.includeHidden).toBe(false);
+      expect(result.data.scan.concurrency).toBe(5);
+      expect(result.data.github.defaultVisibility).toBe("private");
+      expect(result.data.display.showSubmodules).toBe(true);
+      expect(result.data.display.sortBy).toBe("status");
+      expect(result.data.display.sortDirection).toBe("desc");
+      expect(result.data.cache.ttlSeconds).toBe(300);
+    }
+  });
+
+  test("validates complete config", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [
+        { path: "~/projects", maxDepth: 3, label: "Projects" },
+        { path: "~/work", maxDepth: 2 },
+      ],
+      scan: {
+        ignore: ["node_modules", "vendor"],
+        includeHidden: true,
+        concurrency: 10,
+      },
+      github: {
+        defaultVisibility: "public",
+      },
+      display: {
+        showSubmodules: false,
+        sortBy: "name",
+        sortDirection: "asc",
+      },
+      cache: {
+        ttlSeconds: 600,
+        githubTtlSeconds: 1200,
+        enableBackgroundRefresh: true,
+        backgroundRefreshIntervalSeconds: 600,
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.directories).toHaveLength(2);
+      expect(result.data.scan.includeHidden).toBe(true);
+      expect(result.data.scan.concurrency).toBe(10);
+      expect(result.data.github.defaultVisibility).toBe("public");
+      expect(result.data.display.showSubmodules).toBe(false);
+      expect(result.data.display.sortBy).toBe("name");
+    }
+  });
+
+  test("rejects empty directories array", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [],
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects invalid sortBy value", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+      display: {
+        sortBy: "invalid",
+      },
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects invalid visibility value", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+      github: {
+        defaultVisibility: "internal",
+      },
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects negative maxDepth", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects", maxDepth: -1 }],
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects maxDepth greater than 10", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects", maxDepth: 11 }],
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects concurrency less than 1", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+      scan: { concurrency: 0 },
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects concurrency greater than 20", () => {
+    const result = GitforestConfigSchema.safeParse({
+      directories: [{ path: "~/projects" }],
+      scan: { concurrency: 21 },
+    });
+
+    expect(result.success).toBe(false);
+  });
+});

package/test/unit/utils/array.test.ts

@@ -0,0 +1,73 @@
+import { describe, test, expect } from "bun:test";
+import { chunk } from "../../../src/utils/array";
+
+describe("chunk", () => {
+  test("splits array into correct chunk sizes", () => {
+    const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    const result = chunk(arr, 3);
+    expect(result).toEqual([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+  });
+
+  test("handles empty array", () => {
+    const result = chunk([], 3);
+    expect(result).toEqual([]);
+  });
+
+  test("handles array smaller than chunk size", () => {
+    const arr = [1, 2];
+    const result = chunk(arr, 5);
+    expect(result).toEqual([[1, 2]]);
+  });
+
+  test("handles exact multiple of chunk size", () => {
+    const arr = [1, 2, 3, 4, 5, 6];
+    const result = chunk(arr, 2);
+    expect(result).toEqual([[1, 2], [3, 4], [5, 6]]);
+  });
+
+  test("handles chunk size of 1", () => {
+    const arr = [1, 2, 3];
+    const result = chunk(arr, 1);
+    expect(result).toEqual([[1], [2], [3]]);
+  });
+
+  test("handles chunk size larger than array", () => {
+    const arr = [1, 2, 3];
+    const result = chunk(arr, 10);
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  test("handles remainder", () => {
+    const arr = [1, 2, 3, 4, 5];
+    const result = chunk(arr, 2);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  test("handles string arrays", () => {
+    const arr = ["a", "b", "c", "d", "e"];
+    const result = chunk(arr, 2);
+    expect(result).toEqual([["a", "b"], ["c", "d"], ["e"]]);
+  });
+
+  test("handles object arrays", () => {
+    const arr = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+    const result = chunk(arr, 2);
+    expect(result).toEqual([[{ id: 1 }, { id: 2 }], [{ id: 3 }, { id: 4 }]]);
+  });
+
+  test("does not modify original array", () => {
+    const arr = [1, 2, 3, 4, 5];
+    const result = chunk(arr, 2);
+    expect(arr).toEqual([1, 2, 3, 4, 5]);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  test("does not modify original array with objects", () => {
+    const arr = [{ id: 1 }, { id: 2 }, { id: 3 }];
+    const result = chunk(arr, 2);
+    // The chunk function uses slice(), which creates a shallow copy
+    // So modifying objects in the result will affect the original
+    result[0]![0]!.id = 99;
+    expect(arr[0]!.id).toBe(99); // Shallow copy means original is modified
+  });
+});

package/test/unit/utils/debug.test.ts

@@ -0,0 +1,23 @@
+import { describe, test, expect } from "bun:test";
+
+describe("debug utilities (basic tests)", () => {
+  test("debug module exports required functions", async () => {
+    const debugModule = await import("../../../src/utils/debug");
+    expect(typeof debugModule.debug).toBe("function");
+    expect(typeof debugModule.debugError).toBe("function");
+    expect(typeof debugModule.isDebugEnabled).toBe("function");
+  });
+
+  test("debug functions don't throw when called", async () => {
+    const debugModule = await import("../../../src/utils/debug");
+    // These should not throw even when debug is disabled
+    expect(() => debugModule.debug("test", "message")).not.toThrow();
+    expect(() => debugModule.debugError("test", "error", new Error("test"))).not.toThrow();
+  });
+
+  test("isDebugEnabled returns boolean", async () => {
+    const debugModule = await import("../../../src/utils/debug");
+    const result = debugModule.isDebugEnabled();
+    expect(typeof result).toBe("boolean");
+  });
+});