@aku11i/phantom 0.1.2 → 0.3.0

package/dist/phantom.js

@@ -3,56 +3,68 @@
 // src/bin/phantom.ts
 import { argv, exit as exit6 } from "node:process";
 
-// src/commands/exec.ts
-import { spawn } from "node:child_process";
-import { exit as exit2 } from "node:process";
-
-// src/gardens/commands/where.ts
-import { access } from "node:fs/promises";
-import { join } from "node:path";
-import { exit } from "node:process";
+// src/commands/create.ts
+import { access as access2, mkdir } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { exit as exit3 } from "node:process";
 
-// src/git/libs/get-git-root.ts
+// src/git/libs/add-worktree.ts
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
+async function addWorktree(options) {
+  const { path, branch, commitish = "HEAD" } = options;
+  await execAsync(`git worktree add "${path}" -b "${branch}" ${commitish}`);
+}
+
+// src/git/libs/get-git-root.ts
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execAsync2 = promisify2(exec2);
 async function getGitRoot() {
-  const { stdout } = await execAsync("git rev-parse --show-toplevel");
+  const { stdout } = await execAsync2("git rev-parse --show-toplevel");
   return stdout.trim();
 }
 
-// src/gardens/commands/where.ts
-async function whereGarden(name) {
+// src/commands/shell.ts
+import { spawn } from "node:child_process";
+import { exit as exit2 } from "node:process";
+
+// src/commands/where.ts
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { exit } from "node:process";
+async function whereWorktree(name) {
   if (!name) {
-    return { success: false, message: "Error: garden name required" };
+    return { success: false, message: "Error: worktree name required" };
   }
   try {
     const gitRoot = await getGitRoot();
-    const gardensPath = join(gitRoot, ".git", "phantom", "gardens");
-    const gardenPath = join(gardensPath, name);
+    const worktreesPath = join(gitRoot, ".git", "phantom", "worktrees");
+    const worktreePath = join(worktreesPath, name);
     try {
-      await access(gardenPath);
+      await access(worktreePath);
     } catch {
       return {
         success: false,
-        message: `Error: Garden '${name}' does not exist`
+        message: `Error: Worktree '${name}' does not exist`
       };
     }
     return {
       success: true,
-      path: gardenPath
+      path: worktreePath
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      message: `Error locating garden: ${errorMessage}`
+      message: `Error locating worktree: ${errorMessage}`
     };
   }
 }
-async function gardensWhereHandler(args2) {
+async function whereHandler(args2) {
   const name = args2[0];
-  const result = await whereGarden(name);
+  const result = await whereWorktree(name);
   if (!result.success) {
     console.error(result.message);
     exit(1);
@@ -60,87 +72,26 @@ async function gardensWhereHandler(args2) {
   console.log(result.path);
 }
 
-// src/commands/exec.ts
-async function execInGarden(gardenName, command2) {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
-  }
-  if (!command2 || command2.length === 0) {
-    return { success: false, message: "Error: command required" };
-  }
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    return { success: false, message: gardenResult.message };
-  }
-  const gardenPath = gardenResult.path;
-  const [cmd, ...args2] = command2;
-  return new Promise((resolve) => {
-    const childProcess = spawn(cmd, args2, {
-      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
-        });
-      }
-    });
-  });
-}
-async function execHandler(args2) {
-  if (args2.length < 2) {
-    console.error("Usage: phantom exec <garden-name> <command> [args...]");
-    exit2(1);
-  }
-  const gardenName = args2[0];
-  const command2 = args2.slice(1);
-  const result = await execInGarden(gardenName, command2);
-  if (!result.success) {
-    if (result.message) {
-      console.error(result.message);
-    }
-    exit2(result.exitCode ?? 1);
-  }
-  exit2(result.exitCode ?? 0);
-}
-
 // src/commands/shell.ts
-import { spawn as spawn2 } from "node:child_process";
-import { exit as exit3 } from "node:process";
-async function shellInGarden(gardenName) {
-  if (!gardenName) {
-    return { success: false, message: "Error: garden name required" };
+async function shellInWorktree(worktreeName) {
+  if (!worktreeName) {
+    return { success: false, message: "Error: worktree name required" };
   }
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    return { success: false, message: gardenResult.message };
+  const worktreeResult = await whereWorktree(worktreeName);
+  if (!worktreeResult.success) {
+    return { success: false, message: worktreeResult.message };
   }
-  const gardenPath = gardenResult.path;
+  const worktreePath = worktreeResult.path;
   const shell = process.env.SHELL || "/bin/sh";
   return new Promise((resolve) => {
-    const childProcess = spawn2(shell, [], {
-      cwd: gardenPath,
+    const childProcess = spawn(shell, [], {
+      cwd: worktreePath,
       stdio: "inherit",
       env: {
         ...process.env,
-        // Add environment variable to indicate we're in a phantom garden
-        PHANTOM_GARDEN: gardenName,
-        PHANTOM_GARDEN_PATH: gardenPath
+        // Add environment variable to indicate we're in a worktree
+        WORKTREE_NAME: worktreeName,
+        WORKTREE_PATH: worktreePath
       }
     });
     childProcess.on("error", (error) => {
@@ -168,120 +119,120 @@ async function shellInGarden(gardenName) {
 }
 async function shellHandler(args2) {
   if (args2.length < 1) {
-    console.error("Usage: phantom shell <garden-name>");
-    exit3(1);
+    console.error("Usage: phantom shell <worktree-name>");
+    exit2(1);
   }
-  const gardenName = args2[0];
-  const gardenResult = await whereGarden(gardenName);
-  if (!gardenResult.success) {
-    console.error(gardenResult.message);
-    exit3(1);
+  const worktreeName = args2[0];
+  const worktreeResult = await whereWorktree(worktreeName);
+  if (!worktreeResult.success) {
+    console.error(worktreeResult.message);
+    exit2(1);
   }
-  console.log(`Entering garden '${gardenName}' at ${gardenResult.path}`);
+  console.log(`Entering worktree '${worktreeName}' at ${worktreeResult.path}`);
   console.log("Type 'exit' to return to your original directory\n");
-  const result = await shellInGarden(gardenName);
+  const result = await shellInWorktree(worktreeName);
   if (!result.success) {
     if (result.message) {
       console.error(result.message);
     }
-    exit3(result.exitCode ?? 1);
+    exit2(result.exitCode ?? 1);
   }
-  exit3(result.exitCode ?? 0);
-}
-
-// src/gardens/commands/create.ts
-import { access as access2, mkdir } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { exit as exit4 } from "node:process";
-
-// src/git/libs/add-worktree.ts
-import { exec as exec2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execAsync2 = promisify2(exec2);
-async function addWorktree(options) {
-  const { path, branch, commitish = "HEAD" } = options;
-  await execAsync2(`git worktree add "${path}" -b "${branch}" ${commitish}`);
+  exit2(result.exitCode ?? 0);
 }
 
-// src/gardens/commands/create.ts
-async function createGarden(name) {
+// src/commands/create.ts
+async function createWorktree(name) {
   if (!name) {
-    return { success: false, message: "Error: garden name required" };
+    return { success: false, message: "Error: worktree name required" };
   }
   try {
     const gitRoot = await getGitRoot();
-    const gardensPath = join2(gitRoot, ".git", "phantom", "gardens");
-    const worktreePath = join2(gardensPath, name);
+    const worktreesPath = join2(gitRoot, ".git", "phantom", "worktrees");
+    const worktreePath = join2(worktreesPath, name);
     try {
-      await access2(gardensPath);
+      await access2(worktreesPath);
     } catch {
-      await mkdir(gardensPath, { recursive: true });
+      await mkdir(worktreesPath, { recursive: true });
     }
     try {
       await access2(worktreePath);
       return {
         success: false,
-        message: `Error: garden '${name}' already exists`
+        message: `Error: worktree '${name}' already exists`
       };
     } catch {
     }
     await addWorktree({
       path: worktreePath,
-      branch: `phantom/gardens/${name}`,
+      branch: name,
       commitish: "HEAD"
     });
     return {
       success: true,
-      message: `Created garden '${name}' at ${worktreePath}`,
+      message: `Created worktree '${name}' at ${worktreePath}`,
       path: worktreePath
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      message: `Error creating garden: ${errorMessage}`
+      message: `Error creating worktree: ${errorMessage}`
     };
   }
 }
-async function gardensCreateHandler(args2) {
+async function createHandler(args2) {
   const name = args2[0];
-  const result = await createGarden(name);
+  const openShell = args2.includes("--shell");
+  const result = await createWorktree(name);
   if (!result.success) {
     console.error(result.message);
-    exit4(1);
+    exit3(1);
   }
   console.log(result.message);
+  if (openShell && result.path) {
+    console.log(`
+Entering worktree '${name}' at ${result.path}`);
+    console.log("Type 'exit' to return to your original directory\n");
+    const shellResult = await shellInWorktree(name);
+    if (!shellResult.success) {
+      if (shellResult.message) {
+        console.error(shellResult.message);
+      }
+      exit3(shellResult.exitCode ?? 1);
+    }
+    exit3(shellResult.exitCode ?? 0);
+  }
 }
 
-// src/gardens/commands/delete.ts
+// src/commands/delete.ts
 import { exec as exec3 } from "node:child_process";
 import { access as access3 } from "node:fs/promises";
 import { join as join3 } from "node:path";
-import { exit as exit5 } from "node:process";
+import { exit as exit4 } from "node:process";
 import { promisify as promisify3 } from "node:util";
 var execAsync3 = promisify3(exec3);
-async function deleteGarden(name, options = {}) {
+async function deleteWorktree(name, options = {}) {
   if (!name) {
-    return { success: false, message: "Error: garden name required" };
+    return { success: false, message: "Error: worktree name required" };
   }
   const { force = false } = options;
   try {
     const gitRoot = await getGitRoot();
-    const gardensPath = join3(gitRoot, ".git", "phantom", "gardens");
-    const gardenPath = join3(gardensPath, name);
+    const worktreesPath = join3(gitRoot, ".git", "phantom", "worktrees");
+    const worktreePath = join3(worktreesPath, name);
     try {
-      await access3(gardenPath);
+      await access3(worktreePath);
     } catch {
       return {
         success: false,
-        message: `Error: Garden '${name}' does not exist`
+        message: `Error: Worktree '${name}' does not exist`
       };
     }
     let hasUncommittedChanges = false;
     let changedFiles = 0;
     try {
       const { stdout } = await execAsync3("git status --porcelain", {
-        cwd: gardenPath
+        cwd: worktreePath
       });
       const changes = stdout.trim();
       if (changes) {
@@ -294,37 +245,37 @@ async function deleteGarden(name, options = {}) {
     if (hasUncommittedChanges && !force) {
       return {
         success: false,
-        message: `Error: Garden '${name}' has uncommitted changes (${changedFiles} files). Use --force to delete anyway.`,
+        message: `Error: Worktree '${name}' has uncommitted changes (${changedFiles} files). Use --force to delete anyway.`,
         hasUncommittedChanges: true,
         changedFiles
       };
     }
     try {
-      await execAsync3(`git worktree remove "${gardenPath}"`, {
+      await execAsync3(`git worktree remove "${worktreePath}"`, {
         cwd: gitRoot
       });
     } catch (error) {
       try {
-        await execAsync3(`git worktree remove --force "${gardenPath}"`, {
+        await execAsync3(`git worktree remove --force "${worktreePath}"`, {
           cwd: gitRoot
         });
       } catch {
         return {
           success: false,
-          message: `Error: Failed to remove worktree for garden '${name}'`
+          message: `Error: Failed to remove worktree '${name}'`
         };
       }
     }
-    const branchName = `phantom/gardens/${name}`;
+    const branchName = `phantom/worktrees/${name}`;
     try {
       await execAsync3(`git branch -D "${branchName}"`, {
         cwd: gitRoot
       });
     } catch {
     }
-    let message = `Deleted garden '${name}' and its branch '${branchName}'`;
+    let message = `Deleted worktree '${name}' and its branch '${branchName}'`;
     if (hasUncommittedChanges) {
-      message = `Warning: Garden '${name}' had uncommitted changes (${changedFiles} files)
+      message = `Warning: Worktree '${name}' had uncommitted changes (${changedFiles} files)
 ${message}`;
     }
     return {
@@ -337,49 +288,110 @@ ${message}`;
     const errorMessage = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      message: `Error deleting garden: ${errorMessage}`
+      message: `Error deleting worktree: ${errorMessage}`
     };
   }
 }
-async function gardensDeleteHandler(args2) {
+async function deleteHandler(args2) {
   const forceIndex = args2.indexOf("--force");
   const force = forceIndex !== -1;
   const filteredArgs = args2.filter((arg) => arg !== "--force");
   const name = filteredArgs[0];
-  const result = await deleteGarden(name, { force });
+  const result = await deleteWorktree(name, { force });
   if (!result.success) {
     console.error(result.message);
-    exit5(1);
+    exit4(1);
   }
   console.log(result.message);
 }
 
-// src/gardens/commands/list.ts
+// src/commands/exec.ts
+import { spawn as spawn2 } from "node:child_process";
+import { exit as exit5 } from "node:process";
+async function execInWorktree(worktreeName, command2) {
+  if (!worktreeName) {
+    return { success: false, message: "Error: worktree name required" };
+  }
+  if (!command2 || command2.length === 0) {
+    return { success: false, message: "Error: command required" };
+  }
+  const worktreeResult = await whereWorktree(worktreeName);
+  if (!worktreeResult.success) {
+    return { success: false, message: worktreeResult.message };
+  }
+  const worktreePath = worktreeResult.path;
+  const [cmd, ...args2] = command2;
+  return new Promise((resolve) => {
+    const childProcess = spawn2(cmd, args2, {
+      cwd: worktreePath,
+      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
+        });
+      }
+    });
+  });
+}
+async function execHandler(args2) {
+  if (args2.length < 2) {
+    console.error("Usage: phantom exec <worktree-name> <command> [args...]");
+    exit5(1);
+  }
+  const worktreeName = args2[0];
+  const command2 = args2.slice(1);
+  const result = await execInWorktree(worktreeName, command2);
+  if (!result.success) {
+    if (result.message) {
+      console.error(result.message);
+    }
+    exit5(result.exitCode ?? 1);
+  }
+  exit5(result.exitCode ?? 0);
+}
+
+// src/commands/list.ts
 import { exec as exec4 } from "node:child_process";
 import { access as access4, readdir } from "node:fs/promises";
 import { join as join4 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execAsync4 = promisify4(exec4);
-async function listGardens() {
+async function listWorktrees() {
   try {
     const gitRoot = await getGitRoot();
-    const gardensPath = join4(gitRoot, ".git", "phantom", "gardens");
+    const worktreesPath = join4(gitRoot, ".git", "phantom", "worktrees");
     try {
-      await access4(gardensPath);
+      await access4(worktreesPath);
     } catch {
       return {
         success: true,
-        gardens: [],
-        message: "No gardens found (gardens directory doesn't exist)"
+        worktrees: [],
+        message: "No worktrees found (worktrees directory doesn't exist)"
       };
     }
-    let gardenNames;
+    let worktreeNames;
     try {
-      const entries = await readdir(gardensPath);
+      const entries = await readdir(worktreesPath);
       const validEntries = await Promise.all(
         entries.map(async (entry) => {
           try {
-            const entryPath = join4(gardensPath, entry);
+            const entryPath = join4(worktreesPath, entry);
             await access4(entryPath);
             return entry;
           } catch {
@@ -387,30 +399,30 @@ async function listGardens() {
           }
         })
       );
-      gardenNames = validEntries.filter(
+      worktreeNames = validEntries.filter(
         (entry) => entry !== null
       );
     } catch {
       return {
         success: true,
-        gardens: [],
-        message: "No gardens found (unable to read gardens directory)"
+        worktrees: [],
+        message: "No worktrees found (unable to read worktrees directory)"
       };
     }
-    if (gardenNames.length === 0) {
+    if (worktreeNames.length === 0) {
       return {
         success: true,
-        gardens: [],
-        message: "No gardens found"
+        worktrees: [],
+        message: "No worktrees found"
       };
     }
-    const gardens = await Promise.all(
-      gardenNames.map(async (name) => {
-        const gardenPath = join4(gardensPath, name);
+    const worktrees = await Promise.all(
+      worktreeNames.map(async (name) => {
+        const worktreePath = join4(worktreesPath, name);
         let branch = "unknown";
         try {
           const { stdout } = await execAsync4("git branch --show-current", {
-            cwd: gardenPath
+            cwd: worktreePath
           });
           branch = stdout.trim() || "detached HEAD";
         } catch {
@@ -420,7 +432,7 @@ async function listGardens() {
         let changedFiles;
         try {
           const { stdout } = await execAsync4("git status --porcelain", {
-            cwd: gardenPath
+            cwd: worktreePath
           });
           const changes = stdout.trim();
           if (changes) {
@@ -440,86 +452,146 @@ async function listGardens() {
     );
     return {
       success: true,
-      gardens
+      worktrees
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return {
       success: false,
-      message: `Error listing gardens: ${errorMessage}`
+      message: `Error listing worktrees: ${errorMessage}`
     };
   }
 }
-async function gardensListHandler() {
-  const result = await listGardens();
+async function listHandler() {
+  const result = await listWorktrees();
   if (!result.success) {
     console.error(result.message);
     return;
   }
-  if (!result.gardens || result.gardens.length === 0) {
-    console.log(result.message || "No gardens found");
+  if (!result.worktrees || result.worktrees.length === 0) {
+    console.log(result.message || "No worktrees found");
     return;
   }
-  console.log("Gardens:");
-  for (const garden of result.gardens) {
-    const statusText = garden.status === "clean" ? "[clean]" : `[dirty: ${garden.changedFiles} files]`;
+  console.log("Worktrees:");
+  for (const worktree of result.worktrees) {
+    const statusText = worktree.status === "clean" ? "[clean]" : `[dirty: ${worktree.changedFiles} files]`;
     console.log(
-      `  ${garden.name.padEnd(20)} (branch: ${garden.branch.padEnd(20)}) ${statusText}`
+      `  ${worktree.name.padEnd(20)} (branch: ${worktree.branch.padEnd(20)}) ${statusText}`
     );
   }
   console.log(`
-Total: ${result.gardens.length} gardens`);
+Total: ${result.worktrees.length} worktrees`);
+}
+
+// package.json
+var package_default = {
+  name: "@aku11i/phantom",
+  packageManager: "pnpm@10.8.1",
+  version: "0.3.0",
+  description: "A powerful CLI tool for managing Git worktrees for parallel development",
+  keywords: [
+    "git",
+    "worktree",
+    "cli",
+    "phantom",
+    "workspace",
+    "development",
+    "parallel"
+  ],
+  homepage: "https://github.com/aku11i/phantom#readme",
+  bugs: {
+    url: "https://github.com/aku11i/phantom/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/aku11i/phantom.git"
+  },
+  license: "MIT",
+  author: "aku11i",
+  type: "module",
+  bin: {
+    phantom: "./dist/phantom.js"
+  },
+  scripts: {
+    start: "node ./src/bin/phantom.ts",
+    phantom: "node ./src/bin/phantom.ts",
+    build: "node build.ts",
+    "type-check": "tsc --noEmit",
+    test: "node --test --experimental-strip-types --experimental-test-module-mocks src/**/*.test.ts",
+    lint: "biome check .",
+    fix: "biome check --write .",
+    ready: "pnpm fix && pnpm type-check && pnpm test",
+    "ready:check": "pnpm lint && pnpm type-check && pnpm test",
+    prepublishOnly: "pnpm ready:check && pnpm build"
+  },
+  engines: {
+    node: ">=22.0.0"
+  },
+  files: [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.15.29",
+    esbuild: "^0.25.5",
+    typescript: "^5.8.3"
+  }
+};
+
+// src/commands/version.ts
+function getVersion() {
+  return package_default.version;
+}
+function versionHandler() {
+  const version = getVersion();
+  console.log(`Phantom v${version}`);
 }
 
 // src/bin/phantom.ts
 var commands = [
   {
-    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: "create",
+    description: "Create a new worktree [--shell to open shell]",
+    handler: createHandler
+  },
+  {
+    name: "list",
+    description: "List all worktrees",
+    handler: listHandler
+  },
+  {
+    name: "where",
+    description: "Output the path of a specific worktree",
+    handler: whereHandler
+  },
+  {
+    name: "delete",
+    description: "Delete a worktree (use --force for uncommitted changes)",
+    handler: deleteHandler
   },
   {
     name: "exec",
-    description: "Execute a command in a garden directory",
+    description: "Execute a command in a worktree directory",
     handler: execHandler
   },
   {
     name: "shell",
-    description: "Open interactive shell in a garden directory",
+    description: "Open interactive shell in a worktree directory",
     handler: shellHandler
+  },
+  {
+    name: "version",
+    description: "Display phantom version",
+    handler: versionHandler
   }
 ];
-function printHelp(commands2, prefix = "") {
+function printHelp(commands2) {
   console.log("Usage: phantom <command> [options]\n");
   console.log("Commands:");
   for (const cmd of commands2) {
-    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}`);
-      }
-    }
+    console.log(`  ${cmd.name.padEnd(12)} ${cmd.description}`);
   }
 }
 function findCommand(args2, commands2) {
@@ -547,6 +619,10 @@ if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
   printHelp(commands);
   exit6(0);
 }
+if (args[0] === "--version" || args[0] === "-v") {
+  versionHandler();
+  exit6(0);
+}
 var { command, remainingArgs } = findCommand(args, commands);
 if (!command || !command.handler) {
   console.error(`Error: Unknown command '${args.join(" ")}'