arbors 0.1.0

package/tests/config.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { mergeConfig, loadConfig } from "../src/config.js";
+import type { ArborConfig } from "../src/config.js";
+
+describe("mergeConfig", () => {
+  it("should override base values with override values", () => {
+    // Given: a base config and an override with different runtime
+    const base = { runtime: "bun", language: "ko" } as ArborConfig;
+    const override = { runtime: "node" } as Partial<ArborConfig>;
+
+    // When: merged
+    const result = mergeConfig(base, override);
+
+    // Then: override wins, base-only values preserved
+    expect(result.runtime).toBe("node");
+    expect(result.language).toBe("ko");
+  });
+
+  it("should not mutate the original base object", () => {
+    // Given: a base config
+    const base = { runtime: "bun", language: "en" } as ArborConfig;
+    const original = structuredClone(base);
+
+    // When: merged with an override
+    mergeConfig(base, { runtime: "node" } as Partial<ArborConfig>);
+
+    // Then: original is untouched
+    expect(base).toEqual(original);
+  });
+
+  it("should return base when override is empty", () => {
+    // Given: a base config and an empty override
+    const base = { runtime: "node", language: "ja" } as ArborConfig;
+
+    // When: merged with empty object
+    const result = mergeConfig(base, {});
+
+    // Then: result matches base
+    expect(result).toEqual(base);
+  });
+});
+
+describe("loadConfig", () => {
+  const mockReadFile = (files: Record<string, string>) => async (path: string) => {
+    if (Object.hasOwn(files, path)) return files[path];
+    throw new Error(`File not found: ${path}`);
+  };
+
+  const mockExists = (files: Record<string, string>) => async (path: string) =>
+    Object.hasOwn(files, path);
+
+  it("should return defaults when no config files exist", async () => {
+    // Given: no config files on disk
+    const readFile = mockReadFile({});
+    const exists = mockExists({});
+
+    // When: config is loaded
+    const config = await loadConfig(readFile, exists);
+
+    // Then: all values are defaults
+    expect(config.runtime).toBe("node");
+    expect(config.language).toBe("en");
+    expect(config.packageManager).toBe("auto");
+    expect(config.copyExcludes).toBe(true);
+  });
+
+  it("should merge project config over global config", async () => {
+    // Given: global sets runtime=bun, project sets runtime=node
+    const home = process.env.HOME ?? "/tmp";
+    const globalPath = `${home}/.arbors/config.json`;
+    const projectPath = "/project/.arbors/config.json";
+
+    const files: Record<string, string> = {
+      [globalPath]: JSON.stringify({ runtime: "bun", language: "ko" }),
+      [projectPath]: JSON.stringify({ runtime: "node" }),
+    };
+
+    const readFile = mockReadFile(files);
+    const exists = mockExists(files);
+
+    // When: config is loaded with a project root
+    const config = await loadConfig(readFile, exists, "/project");
+
+    // Then: project override wins, global-only values preserved
+    expect(config.runtime).toBe("node");
+    expect(config.language).toBe("ko");
+  });
+
+  it("should handle malformed config files gracefully", async () => {
+    // Given: a global config with invalid JSON
+    const home = process.env.HOME ?? "/tmp";
+    const globalPath = `${home}/.arbors/config.json`;
+
+    const files: Record<string, string> = {
+      [globalPath]: "not valid json{{{",
+    };
+
+    const readFile = mockReadFile(files);
+    const exists = mockExists(files);
+
+    // When: config is loaded
+    const config = await loadConfig(readFile, exists);
+
+    // Then: falls back to defaults
+    expect(config.runtime).toBe("node");
+    expect(config.language).toBe("en");
+  });
+});

package/tests/exclude.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi } from "vitest";
+import { getExcludePatterns, findExcludedEntries, copyExcludedFiles } from "../src/git/exclude.js";
+import type { RuntimeAdapter } from "../src/runtime/adapter.js";
+
+const createMockAdapter = (overrides: Partial<RuntimeAdapter> = {}): RuntimeAdapter => ({
+  exec: vi.fn(async () => ({ stdout: "/repo", stderr: "", exitCode: 0 })),
+  glob: vi.fn(async () => []),
+  readFile: vi.fn(async () => ""),
+  writeFile: vi.fn(),
+  exists: vi.fn(async () => true),
+  copy: vi.fn(),
+  mkdir: vi.fn(),
+  ...overrides,
+});
+
+describe("getExcludePatterns", () => {
+  it("should parse patterns from exclude file", async () => {
+    // Given: an exclude file with patterns, comments, and blank lines
+    const adapter = createMockAdapter({
+      readFile: vi.fn(async () => "# comment\n.env\n\nnode_modules\n# another comment\n.secret\n"),
+    });
+
+    // When: patterns are extracted
+    const patterns = await getExcludePatterns(adapter);
+
+    // Then: only non-empty, non-comment lines are returned
+    expect(patterns).toEqual([".env", "node_modules", ".secret"]);
+  });
+
+  it("should return empty array when exclude file does not exist", async () => {
+    // Given: no exclude file
+    const adapter = createMockAdapter({
+      exists: vi.fn(async () => false),
+    });
+
+    // When: patterns are extracted
+    const patterns = await getExcludePatterns(adapter);
+
+    // Then: empty array
+    expect(patterns).toEqual([]);
+  });
+
+  it("should trim whitespace from patterns", async () => {
+    // Given: patterns with extra whitespace
+    const adapter = createMockAdapter({
+      readFile: vi.fn(async () => "  .env  \n  node_modules  \n"),
+    });
+
+    // When: patterns are extracted
+    const patterns = await getExcludePatterns(adapter);
+
+    // Then: patterns are trimmed
+    expect(patterns).toEqual([".env", "node_modules"]);
+  });
+});
+
+describe("findExcludedEntries", () => {
+  it("should glob each pattern and deduplicate results", async () => {
+    // Given: patterns that match overlapping entries
+    const adapter = createMockAdapter({
+      glob: vi.fn(async (pattern: string) => {
+        if (pattern === ".env") return [".env"];
+        if (pattern === ".env*") return [".env", ".env.local"];
+        return [];
+      }),
+    });
+
+    // When: excluded entries are found
+    const entries = await findExcludedEntries(adapter, [".env", ".env*"]);
+
+    // Then: duplicates are removed and sorted
+    expect(entries).toEqual([".env", ".env.local"]);
+  });
+
+  it("should strip leading slashes from patterns", async () => {
+    // Given: a pattern with a leading slash
+    const globFn = vi.fn(async () => ["secret.key"]);
+    const adapter = createMockAdapter({ glob: globFn });
+
+    // When: excluded entries are found
+    await findExcludedEntries(adapter, ["/secret.key"]);
+
+    // Then: glob is called without the leading slash
+    expect(globFn).toHaveBeenCalledWith("secret.key", "/repo");
+  });
+});
+
+describe("copyExcludedFiles", () => {
+  it("should copy each excluded file to the worktree", async () => {
+    // Given: exclude patterns that match two files
+    const copyFn = vi.fn();
+    const mkdirFn = vi.fn();
+    const adapter = createMockAdapter({
+      readFile: vi.fn(async () => ".env\n"),
+      glob: vi.fn(async () => [".env"]),
+      copy: copyFn,
+      mkdir: mkdirFn,
+    });
+
+    // When: excluded files are copied
+    const copied = await copyExcludedFiles(adapter, "/worktree");
+
+    // Then: files are copied from repo root to worktree
+    expect(copied).toEqual([".env"]);
+    expect(copyFn).toHaveBeenCalledWith("/repo/.env", "/worktree/.env");
+  });
+
+  it("should return empty array when no exclude patterns exist", async () => {
+    // Given: no patterns in exclude file
+    const adapter = createMockAdapter({
+      readFile: vi.fn(async () => ""),
+    });
+
+    // When: copy is attempted
+    const copied = await copyExcludedFiles(adapter, "/worktree");
+
+    // Then: nothing is copied
+    expect(copied).toEqual([]);
+  });
+});

package/tests/i18n.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { loadMessages } from "../src/i18n/index.js";
+
+describe("i18n", () => {
+  beforeEach(() => {
+    vi.stubEnv("LANG", "");
+    vi.stubEnv("LANGUAGE", "");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("should load English messages by default", async () => {
+    // Given: no language configured and no LANG env
+    // When: messages are loaded without config
+    const messages = await loadMessages();
+
+    // Then: English messages are returned
+    expect(messages.selectProject).toBe("Select a project:");
+  });
+
+  it("should load Korean messages when configured", async () => {
+    // Given: language is set to ko
+    // When: messages are loaded with ko config
+    const messages = await loadMessages("ko");
+
+    // Then: Korean messages are returned
+    expect(messages.selectProject).toBe("프로젝트를 선택하세요:");
+  });
+
+  it("should load Japanese messages when configured", async () => {
+    // Given: language is set to ja
+    // When: messages are loaded with ja config
+    const messages = await loadMessages("ja");
+
+    // Then: Japanese messages are returned
+    expect(messages.selectProject).toBe("プロジェクトを選択してください:");
+  });
+
+  it("should detect language from LANG env variable", async () => {
+    // Given: LANG is set to ko_KR.UTF-8
+    vi.stubEnv("LANG", "ko_KR.UTF-8");
+
+    // When: messages are loaded without explicit config
+    const messages = await loadMessages();
+
+    // Then: Korean is detected and loaded
+    expect(messages.selectProject).toBe("프로젝트를 선택하세요:");
+  });
+
+  it("should handle resultsFound with correct pluralization", async () => {
+    // Given: English messages
+    const messages = await loadMessages("en");
+
+    // When: resultsFound is called with 1 and 3
+    const singular = messages.resultsFound(1);
+    const plural = messages.resultsFound(3);
+
+    // Then: pluralization is correct
+    expect(singular).toBe("1 result found");
+    expect(plural).toBe("3 results found");
+  });
+
+  it("should fall back to English for unknown locale", async () => {
+    // Given: LANG is set to an unsupported language
+    vi.stubEnv("LANG", "fr_FR.UTF-8");
+
+    // When: messages are loaded
+    const messages = await loadMessages();
+
+    // Then: falls back to English
+    expect(messages.selectProject).toBe("Select a project:");
+  });
+});

package/tests/registry.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  getProjects,
+  getWorktrees,
+  registerProject,
+  registerWorktree,
+  removeProject,
+  unregisterWorktree,
+} from "../src/project/registry.js";
+import type { RuntimeAdapter } from "../src/runtime/adapter.js";
+
+const createMockAdapter = (): RuntimeAdapter & { files: Map<string, string> } => {
+  const files = new Map<string, string>();
+
+  return {
+    files,
+    exec: vi.fn(),
+    glob: vi.fn(),
+    readFile: vi.fn(async (path: string) => {
+      const content = files.get(path);
+      if (!content) throw new Error("Not found");
+      return content;
+    }),
+    writeFile: vi.fn(async (path: string, content: string) => {
+      files.set(path, content);
+    }),
+    exists: vi.fn(async (path: string) => files.has(path)),
+    copy: vi.fn(),
+    mkdir: vi.fn(),
+  };
+};
+
+describe("Project Registry", () => {
+  let adapter: ReturnType<typeof createMockAdapter>;
+
+  beforeEach(() => {
+    adapter = createMockAdapter();
+  });
+
+  it("should return empty list when no projects registered", async () => {
+    // Given: an empty registry (no db.json)
+    // When: projects are fetched
+    const projects = await getProjects(adapter);
+
+    // Then: empty array returned
+    expect(projects).toEqual([]);
+  });
+
+  it("should register and retrieve a project", async () => {
+    // Given: an empty registry
+    // When: a project is registered
+    await registerProject(adapter, "my-app", "/home/user/my-app");
+
+    // Then: it appears in the project list
+    const projects = await getProjects(adapter);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].name).toBe("my-app");
+    expect(projects[0].path).toBe("/home/user/my-app");
+  });
+
+  it("should update lastAccessed when registering an existing project", async () => {
+    // Given: a registered project
+    await registerProject(adapter, "my-app", "/home/user/my-app");
+    const firstAccess = (await getProjects(adapter))[0].lastAccessed;
+
+    // When: the same path is registered again after a delay
+    await new Promise((r) => setTimeout(r, 10));
+    await registerProject(adapter, "my-app", "/home/user/my-app");
+
+    // Then: lastAccessed is updated
+    const projects = await getProjects(adapter);
+    expect(projects).toHaveLength(1);
+    expect(projects[0].lastAccessed).not.toBe(firstAccess);
+  });
+
+  it("should sort projects by most recently accessed", async () => {
+    // Given: two projects registered at different times
+    await registerProject(adapter, "old-app", "/old");
+    await new Promise((r) => setTimeout(r, 10));
+    await registerProject(adapter, "new-app", "/new");
+
+    // When: projects are fetched
+    const projects = await getProjects(adapter);
+
+    // Then: most recent first
+    expect(projects[0].name).toBe("new-app");
+    expect(projects[1].name).toBe("old-app");
+  });
+
+  it("should remove a project by path", async () => {
+    // Given: a registered project
+    await registerProject(adapter, "my-app", "/home/user/my-app");
+
+    // When: removed by path
+    await removeProject(adapter, "/home/user/my-app");
+
+    // Then: no projects remain
+    const projects = await getProjects(adapter);
+    expect(projects).toEqual([]);
+  });
+});
+
+describe("Worktree Registry", () => {
+  let adapter: ReturnType<typeof createMockAdapter>;
+
+  beforeEach(() => {
+    adapter = createMockAdapter();
+  });
+
+  it("should register and retrieve worktrees by project", async () => {
+    await registerWorktree(adapter, "/wt/feature-login", "feature/login", "/repo");
+    await registerWorktree(adapter, "/wt/fix-bug", "fix/bug", "/repo");
+    await registerWorktree(adapter, "/wt/other", "other", "/other-repo");
+
+    const worktrees = await getWorktrees(adapter, "/repo");
+    expect(worktrees).toHaveLength(2);
+    expect(worktrees[0].branch).toBe("feature/login");
+    expect(worktrees[1].branch).toBe("fix/bug");
+  });
+
+  it("should not duplicate worktrees with the same path", async () => {
+    await registerWorktree(adapter, "/wt/feature-login", "feature/login", "/repo");
+    await registerWorktree(adapter, "/wt/feature-login", "feature/login", "/repo");
+
+    const worktrees = await getWorktrees(adapter, "/repo");
+    expect(worktrees).toHaveLength(1);
+  });
+
+  it("should unregister a worktree by path", async () => {
+    await registerWorktree(adapter, "/wt/feature-login", "feature/login", "/repo");
+    await unregisterWorktree(adapter, "/wt/feature-login");
+
+    const worktrees = await getWorktrees(adapter, "/repo");
+    expect(worktrees).toEqual([]);
+  });
+});

package/tests/safety.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { validateWorktreeName } from "../src/git/safety.js";
+
+describe("validateWorktreeName", () => {
+  it("should accept valid alphanumeric names", () => {
+    // Given: valid worktree names
+    const names = ["feature-auth", "fix.login", "release_1.0", "v2"];
+
+    // When/Then: all should be valid
+    names.forEach((name) => {
+      expect(validateWorktreeName(name)).toBe(true);
+    });
+  });
+
+  it("should reject names starting with special characters", () => {
+    // Given: names starting with dot, dash, or underscore
+    const names = [".hidden", "-flag", "_private"];
+
+    // When/Then: all should be invalid
+    names.forEach((name) => {
+      expect(validateWorktreeName(name)).toBe(false);
+    });
+  });
+
+  it("should reject empty strings", () => {
+    // Given: an empty string
+    // When: validated
+    // Then: should be invalid
+    expect(validateWorktreeName("")).toBe(false);
+  });
+
+  it("should reject names with path traversal", () => {
+    // Given: a name containing ".."
+    // When: validated
+    // Then: should be invalid
+    expect(validateWorktreeName("foo..bar")).toBe(false);
+  });
+
+  it("should accept names with slashes for branch conventions", () => {
+    // Given: names with slashes (feature/xxx, fix/xxx patterns)
+    const names = ["feature/login", "fix/ACD-123", "release/1.0"];
+
+    // When/Then: all should be valid
+    names.forEach((name) => {
+      expect(validateWorktreeName(name)).toBe(true);
+    });
+  });
+
+  it("should reject names with spaces or special chars", () => {
+    // Given: names with spaces or special characters
+    const names = ["has space", "has@at"];
+
+    // When/Then: all should be invalid
+    names.forEach((name) => {
+      expect(validateWorktreeName(name)).toBe(false);
+    });
+  });
+});

package/tests/setup-detection.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi } from "vitest";
+import { detectPackageManager, detectRuntimeManager } from "../src/project/setup.js";
+import type { RuntimeAdapter } from "../src/runtime/adapter.js";
+
+const createMockAdapter = (existingFiles: string[]): RuntimeAdapter => ({
+  exec: vi.fn(),
+  glob: vi.fn(),
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  exists: vi.fn(async (path: string) => existingFiles.some((f) => path.endsWith(f))),
+  copy: vi.fn(),
+  mkdir: vi.fn(),
+});
+
+describe("detectPackageManager", () => {
+  it("should detect pnpm from lock file", async () => {
+    // Given: a directory with pnpm-lock.yaml
+    const adapter = createMockAdapter(["pnpm-lock.yaml"]);
+
+    // When: package manager is detected
+    const result = await detectPackageManager(adapter, "/project");
+
+    // Then: pnpm is detected
+    expect(result).toBe("pnpm");
+  });
+
+  it("should detect yarn from lock file", async () => {
+    // Given: a directory with yarn.lock
+    const adapter = createMockAdapter(["yarn.lock"]);
+
+    // When: detected
+    const result = await detectPackageManager(adapter, "/project");
+
+    // Then: yarn
+    expect(result).toBe("yarn");
+  });
+
+  it("should detect npm from lock file", async () => {
+    // Given: a directory with package-lock.json
+    const adapter = createMockAdapter(["package-lock.json"]);
+
+    // When: detected
+    const result = await detectPackageManager(adapter, "/project");
+
+    // Then: npm
+    expect(result).toBe("npm");
+  });
+
+  it("should return null when no lock file found", async () => {
+    // Given: a directory with no lock files
+    const adapter = createMockAdapter([]);
+
+    // When: detected
+    const result = await detectPackageManager(adapter, "/project");
+
+    // Then: null
+    expect(result).toBeNull();
+  });
+
+  it("should prioritize pnpm over yarn when both exist", async () => {
+    // Given: a directory with both pnpm and yarn lock files
+    const adapter = createMockAdapter(["pnpm-lock.yaml", "yarn.lock"]);
+
+    // When: detected
+    const result = await detectPackageManager(adapter, "/project");
+
+    // Then: pnpm wins (first in priority order)
+    expect(result).toBe("pnpm");
+  });
+});
+
+describe("detectRuntimeManager", () => {
+  it("should detect mise from mise.toml", async () => {
+    // Given: a directory with mise.toml
+    const adapter = createMockAdapter(["mise.toml"]);
+
+    // When: detected
+    const result = await detectRuntimeManager(adapter, "/project");
+
+    // Then: mise
+    expect(result).toBe("mise");
+  });
+
+  it("should detect nvm from .nvmrc", async () => {
+    // Given: a directory with .nvmrc
+    const adapter = createMockAdapter([".nvmrc"]);
+
+    // When: detected
+    const result = await detectRuntimeManager(adapter, "/project");
+
+    // Then: nvm
+    expect(result).toBe("nvm");
+  });
+
+  it("should return null when no runtime manager found", async () => {
+    // Given: a directory with no runtime config files
+    const adapter = createMockAdapter([]);
+
+    // When: detected
+    const result = await detectRuntimeManager(adapter, "/project");
+
+    // Then: null
+    expect(result).toBeNull();
+  });
+});

package/tests/setup.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi } from "vitest";
+import { runSetup } from "../src/project/setup.js";
+import type { RuntimeAdapter } from "../src/runtime/adapter.js";
+
+const createMockAdapter = (existingFiles: string[], execLog: string[][] = []): RuntimeAdapter => ({
+  exec: vi.fn(async (cmd: string, args: string[]) => {
+    execLog.push([cmd, ...args]);
+    return { stdout: "", stderr: "", exitCode: 0 };
+  }),
+  glob: vi.fn(),
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  exists: vi.fn(async (path: string) => existingFiles.some((f) => path.endsWith(f))),
+  copy: vi.fn(),
+  mkdir: vi.fn(),
+});
+
+describe("runSetup", () => {
+  it("should detect and run pnpm install", async () => {
+    // Given: a project with pnpm-lock.yaml
+    const execLog: string[][] = [];
+    const adapter = createMockAdapter(["pnpm-lock.yaml"], execLog);
+
+    // When: setup runs with auto detection
+    const result = await runSetup(adapter, "/project");
+
+    // Then: pnpm install is executed
+    expect(result.packageManager).toBe("pnpm");
+    expect(execLog).toContainEqual(["pnpm", "install"]);
+  });
+
+  it("should use config-specified package manager over auto-detect", async () => {
+    // Given: a project with pnpm lock but config says yarn
+    const execLog: string[][] = [];
+    const adapter = createMockAdapter(["pnpm-lock.yaml"], execLog);
+
+    // When: setup runs with yarn override
+    const result = await runSetup(adapter, "/project", "yarn");
+
+    // Then: yarn is used instead of pnpm
+    expect(result.packageManager).toBe("yarn");
+    expect(execLog).toContainEqual(["yarn", "install"]);
+  });
+
+  it("should detect and run mise install before package manager", async () => {
+    // Given: a project with mise.toml and pnpm-lock.yaml
+    const execLog: string[][] = [];
+    const adapter = createMockAdapter(["mise.toml", "pnpm-lock.yaml"], execLog);
+
+    // When: setup runs
+    const result = await runSetup(adapter, "/project");
+
+    // Then: mise runs first, then pnpm
+    expect(result.runtimeManager).toBe("mise");
+    expect(result.packageManager).toBe("pnpm");
+    const miseIndex = execLog.findIndex((c) => c[0] === "mise");
+    const pnpmIndex = execLog.findIndex((c) => c[0] === "pnpm");
+    expect(miseIndex).toBeLessThan(pnpmIndex);
+  });
+
+  it("should skip package manager when no lock file and auto mode", async () => {
+    // Given: a project with no lock files
+    const execLog: string[][] = [];
+    const adapter = createMockAdapter([], execLog);
+
+    // When: setup runs
+    const result = await runSetup(adapter, "/project");
+
+    // Then: no package manager is detected or run
+    expect(result.packageManager).toBeNull();
+    expect(execLog).toHaveLength(0);
+  });
+
+  it("should detect nvm and source nvm.sh before nvm install", async () => {
+    // Given: a project with .nvmrc
+    const execLog: string[][] = [];
+    const adapter = createMockAdapter([".nvmrc"], execLog);
+
+    // When: setup runs
+    const result = await runSetup(adapter, "/project");
+
+    // Then: nvm is detected and invoked via bash -c
+    expect(result.runtimeManager).toBe("nvm");
+    expect(execLog[0][0]).toBe("bash");
+    expect(execLog[0][1]).toBe("-c");
+  });
+});