@aku11i/phantom 0.1.0 → 0.1.2

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

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

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

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

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