@aku11i/phantom 0.1.0 → 0.1.2

package/src/gardens/commands/list.ts

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

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

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

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

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

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