@aku11i/phantom 0.1.0 → 0.1.2

package/src/bin/garden.ts

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { argv, exit } from "node:process";
-import { gardensCreateHandler } from "../gardens/commands/create.ts";
-import { gardensDeleteHandler } from "../gardens/commands/delete.ts";
-import { gardensListHandler } from "../gardens/commands/list.ts";
-import { gardensWhereHandler } from "../gardens/commands/where.ts";
-
-interface Command {
-  name: string;
-  description: string;
-  handler?: (args: string[]) => void | Promise<void>;
-}
-
-const commands: Command[] = [
-  {
-    name: "create",
-    description: "Create a new worktree (garden)",
-    handler: gardensCreateHandler,
-  },
-  {
-    name: "list",
-    description: "List all gardens",
-    handler: gardensListHandler,
-  },
-  {
-    name: "where",
-    description: "Output the path of a specific garden",
-    handler: gardensWhereHandler,
-  },
-  {
-    name: "delete",
-    description: "Delete a garden (use --force for dirty gardens)",
-    handler: gardensDeleteHandler,
-  },
-];
-
-function printHelp() {
-  console.log("Usage: garden <command> [options]\n");
-  console.log("Commands:");
-  for (const cmd of commands) {
-    console.log(`  ${cmd.name.padEnd(20)} ${cmd.description}`);
-  }
-  console.log("\nThis is an alias for 'phantom garden' commands.");
-}
-
-function findCommand(cmdName: string, commands: Command[]): Command | null {
-  return commands.find((cmd) => cmd.name === cmdName) || null;
-}
-
-const args = argv.slice(2);
-
-if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-  printHelp();
-  exit(0);
-}
-
-const command = findCommand(args[0], commands);
-
-if (!command || !command.handler) {
-  console.error(`Error: Unknown command '${args[0]}'\n`);
-  printHelp();
-  exit(1);
-}
-
-try {
-  await command.handler(args.slice(1));
-} catch (error) {
-  console.error(
-    "Error:",
-    error instanceof Error ? error.message : String(error),
-  );
-  exit(1);
-}

package/src/bin/phantom.ts

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-
-import { argv, exit } from "node:process";
-import { execHandler } from "../commands/exec.ts";
-import { shellHandler } from "../commands/shell.ts";
-import { gardensCreateHandler } from "../gardens/commands/create.ts";
-import { gardensDeleteHandler } from "../gardens/commands/delete.ts";
-import { gardensListHandler } from "../gardens/commands/list.ts";
-import { gardensWhereHandler } from "../gardens/commands/where.ts";
-
-interface Command {
-  name: string;
-  description: string;
-  subcommands?: Command[];
-  handler?: (args: string[]) => void | Promise<void>;
-}
-
-const commands: Command[] = [
-  {
-    name: "garden",
-    description: "Manage git worktrees (gardens)",
-    subcommands: [
-      {
-        name: "create",
-        description: "Create a new worktree (garden)",
-        handler: gardensCreateHandler,
-      },
-      {
-        name: "list",
-        description: "List all gardens",
-        handler: gardensListHandler,
-      },
-      {
-        name: "where",
-        description: "Output the path of a specific garden",
-        handler: gardensWhereHandler,
-      },
-      {
-        name: "delete",
-        description: "Delete a garden (use --force for dirty gardens)",
-        handler: gardensDeleteHandler,
-      },
-    ],
-  },
-  {
-    name: "exec",
-    description: "Execute a command in a garden directory",
-    handler: execHandler,
-  },
-  {
-    name: "shell",
-    description: "Open interactive shell in a garden directory",
-    handler: shellHandler,
-  },
-];
-
-function printHelp(commands: Command[], prefix = "") {
-  console.log("Usage: phantom <command> [options]\n");
-  console.log("Commands:");
-  for (const cmd of commands) {
-    console.log(`  ${prefix}${cmd.name.padEnd(20)} ${cmd.description}`);
-    if (cmd.subcommands) {
-      for (const subcmd of cmd.subcommands) {
-        console.log(`    ${subcmd.name.padEnd(18)} ${subcmd.description}`);
-      }
-    }
-  }
-}
-
-function findCommand(
-  args: string[],
-  commands: Command[],
-): { command: Command | null; remainingArgs: string[] } {
-  if (args.length === 0) {
-    return { command: null, remainingArgs: [] };
-  }
-
-  const [cmdName, ...rest] = args;
-  const command = commands.find((cmd) => cmd.name === cmdName);
-
-  if (!command) {
-    return { command: null, remainingArgs: args };
-  }
-
-  if (command.subcommands && rest.length > 0) {
-    const { command: subcommand, remainingArgs } = findCommand(
-      rest,
-      command.subcommands,
-    );
-    if (subcommand) {
-      return { command: subcommand, remainingArgs };
-    }
-  }
-
-  return { command, remainingArgs: rest };
-}
-
-const args = argv.slice(2);
-
-if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-  printHelp(commands);
-  exit(0);
-}
-
-const { command, remainingArgs } = findCommand(args, commands);
-
-if (!command || !command.handler) {
-  console.error(`Error: Unknown command '${args.join(" ")}'\n`);
-  printHelp(commands);
-  exit(1);
-}
-
-try {
-  await command.handler(remainingArgs);
-} catch (error) {
-  console.error(
-    "Error:",
-    error instanceof Error ? error.message : String(error),
-  );
-  exit(1);
-}

package/src/commands/exec.test.ts

@@ -1,256 +0,0 @@
-import { strictEqual } from "node:assert";
-import { before, describe, it, mock } from "node:test";
-
-describe("execInGarden", () => {
-  let spawnMock: ReturnType<typeof mock.fn>;
-  let whereGardenMock: ReturnType<typeof mock.fn>;
-  let execInGarden: typeof import("./exec.ts").execInGarden;
-
-  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,
-      },
-    });
-
-    ({ execInGarden } = await import("./exec.ts"));
-  });
-
-  it("should return error when garden name is not provided", async () => {
-    const result = await execInGarden("", ["echo", "test"]);
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error: garden name required");
-  });
-
-  it("should return error when command is not provided", async () => {
-    const result = await execInGarden("test-garden", []);
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error: command 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 execInGarden("nonexistent", ["echo", "test"]);
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error: Garden 'nonexistent' does not exist");
-  });
-
-  it("should execute command 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 command execution
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            // Simulate successful command (exit code 0)
-            setTimeout(() => callback(0, null), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await execInGarden("test-garden", ["echo", "hello"]);
-
-    strictEqual(result.success, true);
-    strictEqual(result.exitCode, 0);
-
-    // Verify spawn was called with correct arguments
-    strictEqual(spawnMock.mock.calls.length, 1);
-    const [cmd, args, options] = spawnMock.mock.calls[0].arguments as [
-      string,
-      string[],
-      { cwd: string; stdio: string },
-    ];
-    strictEqual(cmd, "echo");
-    strictEqual(args[0], "hello");
-    strictEqual(options.cwd, "/test/repo/.git/phantom/gardens/test-garden");
-    strictEqual(options.stdio, "inherit");
-  });
-
-  it("should handle command 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 command execution
-    const mockChildProcess = {
-      on: mock.fn(
-        (
-          event: string,
-          callback: (code: number | null, signal: string | null) => void,
-        ) => {
-          if (event === "exit") {
-            // Simulate failed command (exit code 1)
-            setTimeout(() => callback(1, null), 0);
-          }
-        },
-      ),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await execInGarden("test-garden", ["false"]);
-
-    strictEqual(result.success, false);
-    strictEqual(result.exitCode, 1);
-  });
-
-  it("should handle command execution 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 command execution error
-    const mockChildProcess = {
-      on: mock.fn((event: string, callback: (error: Error) => void) => {
-        if (event === "error") {
-          setTimeout(() => callback(new Error("Command not found")), 0);
-        }
-      }),
-    };
-
-    spawnMock.mock.mockImplementation(() => mockChildProcess);
-
-    const result = await execInGarden("test-garden", ["nonexistent-command"]);
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Error executing command: Command 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 execInGarden("test-garden", ["long-running-command"]);
-
-    strictEqual(result.success, false);
-    strictEqual(result.message, "Command terminated by signal: SIGTERM");
-    strictEqual(result.exitCode, 143); // 128 + 15 (SIGTERM)
-  });
-
-  it("should parse complex commands with multiple arguments", 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 command execution
-    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);
-
-    const result = await execInGarden("test-garden", [
-      "npm",
-      "run",
-      "test",
-      "--",
-      "--verbose",
-    ]);
-
-    strictEqual(result.success, true);
-    strictEqual(result.exitCode, 0);
-
-    // Verify spawn was called with correct arguments
-    const [cmd, args] = spawnMock.mock.calls[0].arguments as [
-      string,
-      string[],
-      object,
-    ];
-    strictEqual(cmd, "npm");
-    strictEqual(args.length, 4);
-    strictEqual(args[0], "run");
-    strictEqual(args[1], "test");
-    strictEqual(args[2], "--");
-    strictEqual(args[3], "--verbose");
-  });
-});

package/src/commands/exec.ts

@@ -1,81 +0,0 @@
-import { spawn } from "node:child_process";
-import { exit } from "node:process";
-import { whereGarden } from "../gardens/commands/where.ts";
-
-export async function execInGarden(
-  gardenName: string,
-  command: string[],
-): Promise<{
-  success: boolean;
-  message?: string;
-  exitCode?: number;
-}> {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
-  }
-
-  if (!command || command.length === 0) {
-    return { success: false, message: "Error: command 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;
-  const [cmd, ...args] = command;
-
-  return new Promise((resolve) => {
-    const childProcess = spawn(cmd, args, {
-      cwd: gardenPath,
-      stdio: "inherit",
-    });
-
-    childProcess.on("error", (error) => {
-      resolve({
-        success: false,
-        message: `Error executing command: ${error.message}`,
-      });
-    });
-
-    childProcess.on("exit", (code, signal) => {
-      if (signal) {
-        resolve({
-          success: false,
-          message: `Command terminated by signal: ${signal}`,
-          exitCode: 128 + (signal === "SIGTERM" ? 15 : 1),
-        });
-      } else {
-        const exitCode = code ?? 0;
-        resolve({
-          success: exitCode === 0,
-          exitCode,
-        });
-      }
-    });
-  });
-}
-
-export async function execHandler(args: string[]): Promise<void> {
-  if (args.length < 2) {
-    console.error("Usage: phantom exec <garden-name> <command> [args...]");
-    exit(1);
-  }
-
-  const gardenName = args[0];
-  const command = args.slice(1);
-
-  const result = await execInGarden(gardenName, command);
-
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
-    }
-    exit(result.exitCode ?? 1);
-  }
-
-  // For successful commands, exit with the same code as the child process
-  exit(result.exitCode ?? 0);
-}