@aku11i/phantom 0.1.0

package/src/gardens/commands/list.test.ts

@@ -0,0 +1,243 @@
+import { deepStrictEqual, strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("listGardens", () => {
+  let accessMock: ReturnType<typeof mock.fn>;
+  let readdirMock: ReturnType<typeof mock.fn>;
+  let execMock: ReturnType<typeof mock.fn>;
+  let listGardens: typeof import("./list.ts").listGardens;
+
+  before(async () => {
+    accessMock = mock.fn();
+    readdirMock = mock.fn();
+    execMock = mock.fn();
+
+    mock.module("node:fs/promises", {
+      namedExports: {
+        access: accessMock,
+        readdir: readdirMock,
+      },
+    });
+
+    mock.module("node:child_process", {
+      namedExports: {
+        exec: execMock,
+      },
+    });
+
+    mock.module("node:util", {
+      namedExports: {
+        promisify: (fn: unknown) => fn,
+      },
+    });
+
+    ({ listGardens } = await import("./list.ts"));
+  });
+
+  it("should return empty array when gardens directory doesn't exist", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock gardens directory doesn't exist
+    accessMock.mock.mockImplementation((path: string) => {
+      if (path === "/test/repo/.git/phantom/gardens") {
+        return Promise.reject(new Error("ENOENT"));
+      }
+      return Promise.resolve();
+    });
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    deepStrictEqual(result.gardens, []);
+    strictEqual(
+      result.message,
+      "No gardens found (gardens directory doesn't exist)",
+    );
+  });
+
+  it("should return empty array when gardens directory is empty", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock gardens directory exists but is empty
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+    readdirMock.mock.mockImplementation(() => Promise.resolve([]));
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    deepStrictEqual(result.gardens, []);
+    strictEqual(result.message, "No gardens found");
+  });
+
+  it("should list gardens with clean status", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot and git commands
+    execMock.mock.mockImplementation(
+      (cmd: string, options?: { cwd?: string }) => {
+        if (cmd === "git rev-parse --show-toplevel") {
+          return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+        }
+        if (cmd === "git branch --show-current") {
+          if (options?.cwd?.includes("test-garden-1")) {
+            return Promise.resolve({ stdout: "feature/test\n", stderr: "" });
+          }
+          if (options?.cwd?.includes("test-garden-2")) {
+            return Promise.resolve({ stdout: "main\n", stderr: "" });
+          }
+        }
+        if (cmd === "git status --porcelain") {
+          return Promise.resolve({ stdout: "", stderr: "" }); // Clean status
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock gardens directory and contents
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+    readdirMock.mock.mockImplementation(() =>
+      Promise.resolve(["test-garden-1", "test-garden-2"]),
+    );
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    strictEqual(result.gardens?.length, 2);
+    strictEqual(result.gardens?.[0].name, "test-garden-1");
+    strictEqual(result.gardens?.[0].branch, "feature/test");
+    strictEqual(result.gardens?.[0].status, "clean");
+    strictEqual(result.gardens?.[1].name, "test-garden-2");
+    strictEqual(result.gardens?.[1].branch, "main");
+    strictEqual(result.gardens?.[1].status, "clean");
+  });
+
+  it("should list gardens with dirty status", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot and git commands
+    execMock.mock.mockImplementation(
+      (cmd: string, options?: { cwd?: string }) => {
+        if (cmd === "git rev-parse --show-toplevel") {
+          return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+        }
+        if (cmd === "git branch --show-current") {
+          return Promise.resolve({ stdout: "feature/dirty\n", stderr: "" });
+        }
+        if (cmd === "git status --porcelain") {
+          return Promise.resolve({
+            stdout: " M file1.ts\n?? file2.ts\n",
+            stderr: "",
+          }); // Dirty status with 2 files
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock gardens directory and contents
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+    readdirMock.mock.mockImplementation(() =>
+      Promise.resolve(["dirty-garden"]),
+    );
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    strictEqual(result.gardens?.length, 1);
+    strictEqual(result.gardens?.[0].name, "dirty-garden");
+    strictEqual(result.gardens?.[0].branch, "feature/dirty");
+    strictEqual(result.gardens?.[0].status, "dirty");
+    strictEqual(result.gardens?.[0].changedFiles, 2);
+  });
+
+  it("should handle git command errors gracefully", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot and failing git commands
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      if (cmd === "git branch --show-current") {
+        return Promise.reject(new Error("Not a git repository"));
+      }
+      if (cmd === "git status --porcelain") {
+        return Promise.reject(new Error("Git command failed"));
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock gardens directory and contents
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+    readdirMock.mock.mockImplementation(() =>
+      Promise.resolve(["error-garden"]),
+    );
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    strictEqual(result.gardens?.length, 1);
+    strictEqual(result.gardens?.[0].name, "error-garden");
+    strictEqual(result.gardens?.[0].branch, "unknown");
+    strictEqual(result.gardens?.[0].status, "clean");
+  });
+
+  it("should handle detached HEAD state", async () => {
+    accessMock.mock.resetCalls();
+    readdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot and git commands
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      if (cmd === "git branch --show-current") {
+        return Promise.resolve({ stdout: "\n", stderr: "" }); // Empty output = detached HEAD
+      }
+      if (cmd === "git status --porcelain") {
+        return Promise.resolve({ stdout: "", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock gardens directory and contents
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+    readdirMock.mock.mockImplementation(() =>
+      Promise.resolve(["detached-garden"]),
+    );
+
+    const result = await listGardens();
+
+    strictEqual(result.success, true);
+    strictEqual(result.gardens?.length, 1);
+    strictEqual(result.gardens?.[0].name, "detached-garden");
+    strictEqual(result.gardens?.[0].branch, "detached HEAD");
+    strictEqual(result.gardens?.[0].status, "clean");
+  });
+});

package/src/gardens/commands/list.ts

@@ -0,0 +1,152 @@
+import { exec } from "node:child_process";
+import { access, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { getGitRoot } from "../../git/libs/get-git-root.ts";
+
+const execAsync = promisify(exec);
+
+export interface GardenInfo {
+  name: string;
+  branch: string;
+  status: "clean" | "dirty";
+  changedFiles?: number;
+}
+
+export async function listGardens(): Promise<{
+  success: boolean;
+  message?: string;
+  gardens?: GardenInfo[];
+}> {
+  try {
+    const gitRoot = await getGitRoot();
+    const gardensPath = join(gitRoot, ".git", "phantom", "gardens");
+
+    // Check if gardens directory exists
+    try {
+      await access(gardensPath);
+    } catch {
+      return {
+        success: true,
+        gardens: [],
+        message: "No gardens found (gardens directory doesn't exist)",
+      };
+    }
+
+    // Read gardens directory
+    let gardenNames: string[];
+    try {
+      const entries = await readdir(gardensPath);
+      // Filter entries to only include directories
+      const validEntries = await Promise.all(
+        entries.map(async (entry) => {
+          try {
+            const entryPath = join(gardensPath, entry);
+            await access(entryPath);
+            return entry;
+          } catch {
+            return null;
+          }
+        }),
+      );
+      gardenNames = validEntries.filter(
+        (entry): entry is string => entry !== null,
+      );
+    } catch {
+      return {
+        success: true,
+        gardens: [],
+        message: "No gardens found (unable to read gardens directory)",
+      };
+    }
+
+    if (gardenNames.length === 0) {
+      return {
+        success: true,
+        gardens: [],
+        message: "No gardens found",
+      };
+    }
+
+    // Get detailed information for each garden
+    const gardens: GardenInfo[] = await Promise.all(
+      gardenNames.map(async (name) => {
+        const gardenPath = join(gardensPath, name);
+
+        // Get current branch
+        let branch = "unknown";
+        try {
+          const { stdout } = await execAsync("git branch --show-current", {
+            cwd: gardenPath,
+          });
+          branch = stdout.trim() || "detached HEAD";
+        } catch {
+          branch = "unknown";
+        }
+
+        // Get working directory status
+        let status: "clean" | "dirty" = "clean";
+        let changedFiles: number | undefined;
+        try {
+          const { stdout } = await execAsync("git status --porcelain", {
+            cwd: gardenPath,
+          });
+          const changes = stdout.trim();
+          if (changes) {
+            status = "dirty";
+            changedFiles = changes.split("\n").length;
+          }
+        } catch {
+          // If git status fails, assume unknown status
+          status = "clean";
+        }
+
+        return {
+          name,
+          branch,
+          status,
+          changedFiles,
+        };
+      }),
+    );
+
+    return {
+      success: true,
+      gardens,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Error listing gardens: ${errorMessage}`,
+    };
+  }
+}
+
+export async function gardensListHandler(): Promise<void> {
+  const result = await listGardens();
+
+  if (!result.success) {
+    console.error(result.message);
+    return;
+  }
+
+  if (!result.gardens || result.gardens.length === 0) {
+    console.log(result.message || "No gardens found");
+    return;
+  }
+
+  console.log("Gardens:");
+  for (const garden of result.gardens) {
+    const statusText =
+      garden.status === "clean"
+        ? "[clean]"
+        : `[dirty: ${garden.changedFiles} files]`;
+
+    console.log(
+      `  ${garden.name.padEnd(20)} (branch: ${garden.branch.padEnd(20)}) ${statusText}`,
+    );
+  }
+
+  console.log(`\nTotal: ${result.gardens.length} gardens`);
+}

package/src/gardens/commands/where.test.ts

@@ -0,0 +1,149 @@
+import { strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("whereGarden", () => {
+  let accessMock: ReturnType<typeof mock.fn>;
+  let execMock: ReturnType<typeof mock.fn>;
+  let whereGarden: typeof import("./where.ts").whereGarden;
+
+  before(async () => {
+    accessMock = mock.fn();
+    execMock = mock.fn();
+
+    mock.module("node:fs/promises", {
+      namedExports: {
+        access: accessMock,
+      },
+    });
+
+    mock.module("node:child_process", {
+      namedExports: {
+        exec: execMock,
+      },
+    });
+
+    mock.module("node:util", {
+      namedExports: {
+        promisify: (fn: unknown) => fn,
+      },
+    });
+
+    ({ whereGarden } = await import("./where.ts"));
+  });
+
+  it("should return error when name is not provided", async () => {
+    const result = await whereGarden("");
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: garden name required");
+  });
+
+  it("should return error when garden does not exist", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock garden doesn't exist
+    accessMock.mock.mockImplementation(() => {
+      return Promise.reject(new Error("ENOENT"));
+    });
+
+    const result = await whereGarden("nonexistent-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(
+      result.message,
+      "Error: Garden 'nonexistent-garden' does not exist",
+    );
+  });
+
+  it("should return path when garden exists", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await whereGarden("existing-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(result.path, "/test/repo/.git/phantom/gardens/existing-garden");
+  });
+
+  it("should handle git root detection failures", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot failure
+    execMock.mock.mockImplementation(() => {
+      return Promise.reject(new Error("Not a git repository"));
+    });
+
+    const result = await whereGarden("some-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error locating garden: Not a git repository");
+  });
+
+  it("should handle different garden names correctly", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/different/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await whereGarden("feature-branch-123");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.path,
+      "/different/repo/.git/phantom/gardens/feature-branch-123",
+    );
+  });
+
+  it("should handle special characters in garden names", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock getGitRoot
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await whereGarden("feature-with-dashes_and_underscores");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.path,
+      "/test/repo/.git/phantom/gardens/feature-with-dashes_and_underscores",
+    );
+  });
+});

package/src/gardens/commands/where.ts

@@ -0,0 +1,53 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { exit } from "node:process";
+import { getGitRoot } from "../../git/libs/get-git-root.ts";
+
+export async function whereGarden(name: string): Promise<{
+  success: boolean;
+  message?: string;
+  path?: string;
+}> {
+  if (!name) {
+    return { success: false, message: "Error: garden name required" };
+  }
+
+  try {
+    const gitRoot = await getGitRoot();
+    const gardensPath = join(gitRoot, ".git", "phantom", "gardens");
+    const gardenPath = join(gardensPath, name);
+
+    // Check if garden exists
+    try {
+      await access(gardenPath);
+    } catch {
+      return {
+        success: false,
+        message: `Error: Garden '${name}' does not exist`,
+      };
+    }
+
+    return {
+      success: true,
+      path: gardenPath,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Error locating garden: ${errorMessage}`,
+    };
+  }
+}
+
+export async function gardensWhereHandler(args: string[]): Promise<void> {
+  const name = args[0];
+  const result = await whereGarden(name);
+
+  if (!result.success) {
+    console.error(result.message);
+    exit(1);
+  }
+
+  console.log(result.path);
+}

package/src/git/libs/add-worktree.ts

@@ -0,0 +1,16 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+export interface AddWorktreeOptions {
+  path: string;
+  branch: string;
+  commitish?: string;
+}
+
+export async function addWorktree(options: AddWorktreeOptions): Promise<void> {
+  const { path, branch, commitish = "HEAD" } = options;
+
+  await execAsync(`git worktree add "${path}" -b "${branch}" ${commitish}`);
+}

package/src/git/libs/get-current-branch.ts

@@ -0,0 +1,9 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+export async function getCurrentBranch(): Promise<string> {
+  const { stdout } = await execAsync("git branch --show-current");
+  return stdout.trim();
+}

package/src/git/libs/get-git-root.ts

@@ -0,0 +1,9 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+export async function getGitRoot(): Promise<string> {
+  const { stdout } = await execAsync("git rev-parse --show-toplevel");
+  return stdout.trim();
+}