@aku11i/phantom 0.1.0

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

@@ -0,0 +1,176 @@
+import { deepStrictEqual, strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("createGarden", () => {
+  let accessMock: ReturnType<typeof mock.fn>;
+  let mkdirMock: ReturnType<typeof mock.fn>;
+  let execMock: ReturnType<typeof mock.fn>;
+  let createGarden: typeof import("./create.ts").createGarden;
+
+  before(async () => {
+    accessMock = mock.fn();
+    mkdirMock = mock.fn();
+    execMock = mock.fn((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      if (cmd.startsWith("git worktree add")) {
+        return Promise.resolve({ stdout: "", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    mock.module("node:fs/promises", {
+      namedExports: {
+        access: accessMock,
+        mkdir: mkdirMock,
+      },
+    });
+
+    mock.module("node:child_process", {
+      namedExports: {
+        exec: execMock,
+      },
+    });
+
+    mock.module("node:util", {
+      namedExports: {
+        promisify: (fn: unknown) => fn,
+      },
+    });
+
+    ({ createGarden } = await import("./create.ts"));
+  });
+
+  it("should return error when name is not provided", async () => {
+    const result = await createGarden("");
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error: garden name required");
+  });
+
+  it("should create garden directory when it does not exist", async () => {
+    accessMock.mock.resetCalls();
+    mkdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    accessMock.mock.mockImplementation((path: string) => {
+      if (path === "/test/repo/.git/phantom/gardens") {
+        return Promise.reject(new Error("ENOENT"));
+      }
+      if (path === "/test/repo/.git/phantom/gardens/test-garden") {
+        return Promise.reject(new Error("ENOENT"));
+      }
+      return Promise.resolve();
+    });
+
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      if (cmd.startsWith("git worktree add")) {
+        return Promise.resolve({ stdout: "", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    const result = await createGarden("test-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Created garden 'test-garden' at /test/repo/.git/phantom/gardens/test-garden",
+    );
+    strictEqual(result.path, "/test/repo/.git/phantom/gardens/test-garden");
+
+    strictEqual(mkdirMock.mock.calls.length, 1);
+    deepStrictEqual(mkdirMock.mock.calls[0].arguments, [
+      "/test/repo/.git/phantom/gardens",
+      { recursive: true },
+    ]);
+
+    strictEqual(execMock.mock.calls.length, 2);
+    strictEqual(
+      execMock.mock.calls[0].arguments[0],
+      "git rev-parse --show-toplevel",
+    );
+    strictEqual(
+      execMock.mock.calls[1].arguments[0],
+      'git worktree add "/test/repo/.git/phantom/gardens/test-garden" -b "phantom/gardens/test-garden" HEAD',
+    );
+  });
+
+  it("should return error when garden already exists", async () => {
+    accessMock.mock.resetCalls();
+    mkdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    accessMock.mock.mockImplementation((path: string) => {
+      if (path === "/test/repo/.git/phantom/gardens") {
+        return Promise.resolve();
+      }
+      if (path === "/test/repo/.git/phantom/gardens/existing-garden") {
+        return Promise.resolve();
+      }
+      return Promise.reject(new Error("ENOENT"));
+    });
+    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: "" });
+    });
+
+    const result = await createGarden("existing-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(
+      result.message,
+      "Error: garden 'existing-garden' already exists",
+    );
+  });
+
+  it("should handle git command errors", async () => {
+    accessMock.mock.resetCalls();
+    mkdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    execMock.mock.mockImplementation(() => {
+      return Promise.reject(new Error("Not a git repository"));
+    });
+
+    const result = await createGarden("test-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(result.message, "Error creating garden: Not a git repository");
+  });
+
+  it("should not create gardens directory if it already exists", async () => {
+    accessMock.mock.resetCalls();
+    mkdirMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    accessMock.mock.mockImplementation((path: string) => {
+      if (path === "/test/repo/.git/phantom/gardens") {
+        return Promise.resolve();
+      }
+      if (path === "/test/repo/.git/phantom/gardens/test-garden") {
+        return Promise.reject(new Error("ENOENT"));
+      }
+      return Promise.reject(new Error("ENOENT"));
+    });
+    execMock.mock.mockImplementation((cmd: string) => {
+      if (cmd === "git rev-parse --show-toplevel") {
+        return Promise.resolve({ stdout: "/test/repo\n", stderr: "" });
+      }
+      if (cmd.startsWith("git worktree add")) {
+        return Promise.resolve({ stdout: "", stderr: "" });
+      }
+      return Promise.resolve({ stdout: "", stderr: "" });
+    });
+
+    const result = await createGarden("test-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(mkdirMock.mock.calls.length, 0);
+  });
+});

package/src/gardens/commands/create.ts

@@ -0,0 +1,67 @@
+import { access, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { exit } from "node:process";
+import { addWorktree } from "../../git/libs/add-worktree.ts";
+import { getGitRoot } from "../../git/libs/get-git-root.ts";
+
+export async function createGarden(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 worktreePath = join(gardensPath, name);
+
+    try {
+      await access(gardensPath);
+    } catch {
+      await mkdir(gardensPath, { recursive: true });
+    }
+
+    try {
+      await access(worktreePath);
+      return {
+        success: false,
+        message: `Error: garden '${name}' already exists`,
+      };
+    } catch {
+      // Path doesn't exist, which is what we want
+    }
+
+    await addWorktree({
+      path: worktreePath,
+      branch: `phantom/gardens/${name}`,
+      commitish: "HEAD",
+    });
+
+    return {
+      success: true,
+      message: `Created garden '${name}' at ${worktreePath}`,
+      path: worktreePath,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Error creating garden: ${errorMessage}`,
+    };
+  }
+}
+
+export async function gardensCreateHandler(args: string[]): Promise<void> {
+  const name = args[0];
+  const result = await createGarden(name);
+
+  if (!result.success) {
+    console.error(result.message);
+    exit(1);
+  }
+
+  console.log(result.message);
+}

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

@@ -0,0 +1,316 @@
+import { strictEqual } from "node:assert";
+import { before, describe, it, mock } from "node:test";
+
+describe("deleteGarden", () => {
+  let accessMock: ReturnType<typeof mock.fn>;
+  let execMock: ReturnType<typeof mock.fn>;
+  let deleteGarden: typeof import("./delete.ts").deleteGarden;
+
+  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,
+      },
+    });
+
+    ({ deleteGarden } = await import("./delete.ts"));
+  });
+
+  it("should return error when name is not provided", async () => {
+    const result = await deleteGarden("");
+    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 deleteGarden("nonexistent-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(
+      result.message,
+      "Error: Garden 'nonexistent-garden' does not exist",
+    );
+  });
+
+  it("should delete clean garden successfully", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.resolve({ stdout: "", stderr: "" }); // Clean status
+        }
+        if (cmd.includes("git worktree remove")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git branch -D")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("clean-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Deleted garden 'clean-garden' and its branch 'phantom/gardens/clean-garden'",
+    );
+    strictEqual(result.hasUncommittedChanges, false);
+  });
+
+  it("should refuse to delete dirty garden without --force", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 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 garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("dirty-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(
+      result.message,
+      "Error: Garden 'dirty-garden' has uncommitted changes (2 files). Use --force to delete anyway.",
+    );
+    strictEqual(result.hasUncommittedChanges, true);
+    strictEqual(result.changedFiles, 2);
+  });
+
+  it("should delete dirty garden with --force", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.resolve({
+            stdout: " M file1.ts\n?? file2.ts\n",
+            stderr: "",
+          }); // Dirty status with 2 files
+        }
+        if (cmd.includes("git worktree remove")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git branch -D")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("dirty-garden", { force: true });
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Warning: Garden 'dirty-garden' had uncommitted changes (2 files)\nDeleted garden 'dirty-garden' and its branch 'phantom/gardens/dirty-garden'",
+    );
+    strictEqual(result.hasUncommittedChanges, true);
+    strictEqual(result.changedFiles, 2);
+  });
+
+  it("should handle worktree remove failure and try force removal", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git worktree remove") && !cmd.includes("--force")) {
+          return Promise.reject(new Error("Worktree remove failed"));
+        }
+        if (cmd.includes("git worktree remove --force")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git branch -D")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("stubborn-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Deleted garden 'stubborn-garden' and its branch 'phantom/gardens/stubborn-garden'",
+    );
+  });
+
+  it("should handle case where branch doesn't exist", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git worktree remove")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git branch -D")) {
+          return Promise.reject(new Error("Branch not found"));
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("branch-missing-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Deleted garden 'branch-missing-garden' and its branch 'phantom/gardens/branch-missing-garden'",
+    );
+  });
+
+  it("should return error when force worktree removal also fails", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git worktree remove")) {
+          return Promise.reject(new Error("Worktree removal failed"));
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("impossible-garden");
+
+    strictEqual(result.success, false);
+    strictEqual(
+      result.message,
+      "Error: Failed to remove worktree for garden 'impossible-garden'",
+    );
+  });
+
+  it("should handle git status errors gracefully", async () => {
+    accessMock.mock.resetCalls();
+    execMock.mock.resetCalls();
+
+    // Mock 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 status --porcelain") {
+          return Promise.reject(new Error("Git status failed"));
+        }
+        if (cmd.includes("git worktree remove")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        if (cmd.includes("git branch -D")) {
+          return Promise.resolve({ stdout: "", stderr: "" });
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    );
+
+    // Mock garden exists
+    accessMock.mock.mockImplementation(() => Promise.resolve());
+
+    const result = await deleteGarden("status-error-garden");
+
+    strictEqual(result.success, true);
+    strictEqual(
+      result.message,
+      "Deleted garden 'status-error-garden' and its branch 'phantom/gardens/status-error-garden'",
+    );
+    strictEqual(result.hasUncommittedChanges, false);
+  });
+});

package/src/gardens/commands/delete.ts

@@ -0,0 +1,134 @@
+import { exec } from "node:child_process";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { exit } from "node:process";
+import { promisify } from "node:util";
+import { getGitRoot } from "../../git/libs/get-git-root.ts";
+
+const execAsync = promisify(exec);
+
+export async function deleteGarden(
+  name: string,
+  options: { force?: boolean } = {},
+): Promise<{
+  success: boolean;
+  message: string;
+  hasUncommittedChanges?: boolean;
+  changedFiles?: number;
+}> {
+  if (!name) {
+    return { success: false, message: "Error: garden name required" };
+  }
+
+  const { force = false } = options;
+
+  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`,
+      };
+    }
+
+    // Check for uncommitted changes
+    let hasUncommittedChanges = false;
+    let changedFiles = 0;
+    try {
+      const { stdout } = await execAsync("git status --porcelain", {
+        cwd: gardenPath,
+      });
+      const changes = stdout.trim();
+      if (changes) {
+        hasUncommittedChanges = true;
+        changedFiles = changes.split("\n").length;
+      }
+    } catch {
+      // If git status fails, assume no changes
+      hasUncommittedChanges = false;
+    }
+
+    // If garden has uncommitted changes and --force is not specified, refuse deletion
+    if (hasUncommittedChanges && !force) {
+      return {
+        success: false,
+        message: `Error: Garden '${name}' has uncommitted changes (${changedFiles} files). Use --force to delete anyway.`,
+        hasUncommittedChanges: true,
+        changedFiles,
+      };
+    }
+
+    // Remove git worktree
+    try {
+      await execAsync(`git worktree remove "${gardenPath}"`, {
+        cwd: gitRoot,
+      });
+    } catch (error) {
+      // If worktree remove fails, try force removal
+      try {
+        await execAsync(`git worktree remove --force "${gardenPath}"`, {
+          cwd: gitRoot,
+        });
+      } catch {
+        return {
+          success: false,
+          message: `Error: Failed to remove worktree for garden '${name}'`,
+        };
+      }
+    }
+
+    // Delete associated branch
+    const branchName = `phantom/gardens/${name}`;
+    try {
+      await execAsync(`git branch -D "${branchName}"`, {
+        cwd: gitRoot,
+      });
+    } catch {
+      // Branch might not exist or already deleted - this is not an error
+      // We'll still report success for the worktree removal
+    }
+
+    let message = `Deleted garden '${name}' and its branch '${branchName}'`;
+    if (hasUncommittedChanges) {
+      message = `Warning: Garden '${name}' had uncommitted changes (${changedFiles} files)\n${message}`;
+    }
+
+    return {
+      success: true,
+      message,
+      hasUncommittedChanges,
+      changedFiles: hasUncommittedChanges ? changedFiles : undefined,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Error deleting garden: ${errorMessage}`,
+    };
+  }
+}
+
+export async function gardensDeleteHandler(args: string[]): Promise<void> {
+  // Parse arguments for --force flag
+  const forceIndex = args.indexOf("--force");
+  const force = forceIndex !== -1;
+
+  // Remove --force from args to get the garden name
+  const filteredArgs = args.filter((arg) => arg !== "--force");
+  const name = filteredArgs[0];
+
+  const result = await deleteGarden(name, { force });
+
+  if (!result.success) {
+    console.error(result.message);
+    exit(1);
+  }
+
+  console.log(result.message);
+}