gitforest 0.1.0 → 1.0.0

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

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

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

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

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