@aku11i/phantom 0.1.0 → 0.1.2

package/src/commands/shell.test.ts

@@ -1,248 +0,0 @@
-import { strictEqual } from "node:assert";
-import { before, describe, it, mock } from "node:test";
-
-describe("shellInGarden", () => {
-  let spawnMock: ReturnType<typeof mock.fn>;
-  let whereGardenMock: ReturnType<typeof mock.fn>;
-  let shellInGarden: typeof import("./shell.ts").shellInGarden;
-  const originalEnv = process.env;
-
-  before(async () => {
-    spawnMock = mock.fn();
-    whereGardenMock = mock.fn();
-
-    mock.module("node:child_process", {
-      namedExports: {
-        spawn: spawnMock,
-      },
-    });
-
-    mock.module("../gardens/commands/where.ts", {
-      namedExports: {
-        whereGarden: whereGardenMock,
-      },
-    });
-
-    ({ shellInGarden } = await import("./shell.ts"));
-  });
-
-  it("should return error when garden name is not provided", async () => {
-    const result = await shellInGarden("");
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error: garden name required");
-  });
-
-  it("should return error when garden does not exist", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: false,
-        message: "Error: Garden 'nonexistent' does not exist",
-      }),
-    );
-
-    const result = await shellInGarden("nonexistent");
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error: Garden 'nonexistent' does not exist");
-  });
-
-  it("should start shell successfully with exit code 0", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    // Mock successful garden location
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: true,
-        path: "/test/repo/.git/phantom/gardens/test-garden",
-      }),
-    );
-
-    // Mock successful shell session
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            // Simulate successful shell exit
-            setTimeout(() => callback(0, null), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await shellInGarden("test-garden");
-
-    strictEqual(result.success, true);
-    strictEqual(result.exitCode, 0);
-
-    // Verify spawn was called with correct arguments
-    strictEqual(spawnMock.mock.calls.length, 1);
-    const [shell, args, options] = spawnMock.mock.calls[0].arguments as [
-      string,
-      string[],
-      { cwd: string; stdio: string; env: NodeJS.ProcessEnv },
-    ];
-    strictEqual(shell, process.env.SHELL || "/bin/sh");
-    strictEqual(args.length, 0);
-    strictEqual(options.cwd, "/test/repo/.git/phantom/gardens/test-garden");
-    strictEqual(options.stdio, "inherit");
-    strictEqual(options.env.PHANTOM_GARDEN, "test-garden");
-    strictEqual(
-      options.env.PHANTOM_GARDEN_PATH,
-      "/test/repo/.git/phantom/gardens/test-garden",
-    );
-  });
-
-  it("should use /bin/sh when SHELL is not set", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    // Temporarily remove SHELL env var
-    const originalShell = process.env.SHELL;
-    // biome-ignore lint/performance/noDelete: Need to actually delete for test
-    delete process.env.SHELL;
-
-    // Mock successful garden location
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: true,
-        path: "/test/repo/.git/phantom/gardens/test-garden",
-      }),
-    );
-
-    // Mock successful shell session
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            setTimeout(() => callback(0, null), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    await shellInGarden("test-garden");
-
-    // Verify /bin/sh was used
-    const [shell] = spawnMock.mock.calls[0].arguments as [string, unknown];
-    strictEqual(shell, "/bin/sh");
-
-    // Restore SHELL env var
-    if (originalShell !== undefined) {
-      process.env.SHELL = originalShell;
-    }
-  });
-
-  it("should handle shell execution failure with non-zero exit code", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    // Mock successful garden location
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: true,
-        path: "/test/repo/.git/phantom/gardens/test-garden",
-      }),
-    );
-
-    // Mock failed shell session
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            // Simulate failed shell exit
-            setTimeout(() => callback(1, null), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await shellInGarden("test-garden");
-
-    strictEqual(result.success, false);
-    strictEqual(result.exitCode, 1);
-  });
-
-  it("should handle shell startup error", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    // Mock successful garden location
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: true,
-        path: "/test/repo/.git/phantom/gardens/test-garden",
-      }),
-    );
-
-    // Mock shell startup error
-    const mockChildProcess = {
-      on: mock.fn((event: string, callback: (error: Error) => void) => {
-        if (event === "error") {
-          setTimeout(() => callback(new Error("Shell not found")), 0);
-        }
-      }),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await shellInGarden("test-garden");
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error starting shell: Shell not found");
-  });
-
-  it("should handle signal termination", async () => {
-    whereGardenMock.mock.resetCalls();
-    spawnMock.mock.resetCalls();
-
-    // Mock successful garden location
-    whereGardenMock.mock.mockImplementation(() =>
-      Promise.resolve({
-        success: true,
-        path: "/test/repo/.git/phantom/gardens/test-garden",
-      }),
-    );
-
-    // Mock signal termination
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            // Simulate signal termination
-            setTimeout(() => callback(null, "SIGTERM"), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await shellInGarden("test-garden");
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Shell terminated by signal: SIGTERM");
-    strictEqual(result.exitCode, 143); // 128 + 15 (SIGTERM)
-  });
-});

package/src/commands/shell.ts

@@ -1,91 +0,0 @@
-import { spawn } from "node:child_process";
-import { exit } from "node:process";
-import { whereGarden } from "../gardens/commands/where.ts";
-
-export async function shellInGarden(gardenName: string): Promise<{
-  success: boolean;
-  message?: string;
-  exitCode?: number;
-}> {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
-  }
-
-  // Validate garden exists and get its path
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    return { success: false, message: gardenResult.message };
-  }
-
-  const gardenPath = gardenResult.path as string;
-  // Use user's preferred shell or fallback to /bin/sh
-  const shell = process.env.SHELL || "/bin/sh";
-
-  return new Promise((resolve) => {
-    const childProcess = spawn(shell, [], {
-      cwd: gardenPath,
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        // Add environment variable to indicate we're in a phantom garden
-        PHANTOM_GARDEN: gardenName,
-        PHANTOM_GARDEN_PATH: gardenPath,
-      },
-    });
-
-    childProcess.on("error", (error) => {
-      resolve({
-        success: false,
-        message: `Error starting shell: ${error.message}`,
-      });
-    });
-
-    childProcess.on("exit", (code, signal) => {
-      if (signal) {
-        resolve({
-          success: false,
-          message: `Shell terminated by signal: ${signal}`,
-          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1),
-        });
-      } else {
-        const exitCode = code ?? 0;
-        resolve({
-          success: exitCode === 0,
-          exitCode,
-        });
-      }
-    });
-  });
-}
-
-export async function shellHandler(args: string[]): Promise<void> {
-  if (args.length < 1) {
-    console.error("Usage: phantom shell <garden-name>");
-    exit(1);
-  }
-
-  const gardenName = args[0];
-
-  // Get garden path for display
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    console.error(gardenResult.message);
-    exit(1);
-  }
-
-  // Display entering message
-  console.log(`Entering garden '${gardenName}' at ${gardenResult.path}`);
-  console.log("Type 'exit' to return to your original directory\n");
-
-  const result = await shellInGarden(gardenName);
-
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
-    }
-    exit(result.exitCode ?? 1);
-  }
-
-  // Exit with the same code as the shell
-  exit(result.exitCode ?? 0);
-}

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

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

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