ph-cmd 6.0.0-dev.6 → 6.0.0-dev.7

package/build/cli.js

@@ -0,0 +1,1495 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/utils/constants.ts
+import { homedir } from "os";
+import path from "path";
+var PH_BIN_PATH = process.argv[1];
+var PH_BIN = "ph-cli";
+var POWERHOUSE_CONFIG_FILE = "powerhouse.config.json";
+var HOME_DIR = homedir();
+var PH_GLOBAL_DIR_NAME = ".ph";
+var PH_GLOBAL_PACKAGE_NAME = "ph-global";
+var POWERHOUSE_GLOBAL_DIR = path.join(HOME_DIR, PH_GLOBAL_DIR_NAME);
+var packageManagers = {
+  bun: {
+    installCommand: "bun add {{dependency}}",
+    execCommand: `bun ${PH_BIN} {{arguments}}`,
+    execScript: `bun {{arguments}}`,
+    lockfile: "bun.lock",
+    globalPathRegexp: /[\\/].bun[\\/]/,
+    updateCommand: "bun update {{dependency}}",
+    buildAffected: "bun run build:affected",
+    workspaceOption: "",
+    installDepsCommand: "bun install"
+  },
+  pnpm: {
+    installCommand: "pnpm add {{dependency}}",
+    execCommand: `pnpm exec ${PH_BIN} {{arguments}}`,
+    execScript: `pnpm {{arguments}}`,
+    lockfile: "pnpm-lock.yaml",
+    globalPathRegexp: /[\\/]pnpm[\\/]/,
+    updateCommand: "pnpm update {{dependency}}",
+    buildAffected: "pnpm run build:affected",
+    workspaceOption: "--workspace-root",
+    installDepsCommand: "pnpm install"
+  },
+  yarn: {
+    installCommand: "yarn add {{dependency}}",
+    execCommand: `yarn ${PH_BIN} {{arguments}}`,
+    execScript: `yarn {{arguments}}`,
+    lockfile: "yarn.lock",
+    globalPathRegexp: /[\\/]yarn[\\/]/,
+    updateCommand: "yarn upgrade {{dependency}}",
+    buildAffected: "yarn run build:affected",
+    workspaceOption: "-W",
+    installDepsCommand: "yarn install"
+  },
+  npm: {
+    installCommand: "npm install {{dependency}}",
+    execCommand: `npx ${PH_BIN} {{arguments}}`,
+    execScript: `npm run {{arguments}}`,
+    lockfile: "package-lock.json",
+    updateCommand: "npm update {{dependency}} --save",
+    buildAffected: "npm run build:affected",
+    workspaceOption: "",
+    installDepsCommand: "npm install"
+  }
+};
+var PACKAGES_DEPENDENCIES = [
+  "@powerhousedao/builder-tools",
+  "@powerhousedao/codegen",
+  "@powerhousedao/common",
+  "@powerhousedao/config",
+  "@powerhousedao/design-system",
+  "document-drive",
+  "document-model",
+  "@powerhousedao/reactor",
+  "@powerhousedao/reactor-api",
+  "@powerhousedao/reactor-browser",
+  "@powerhousedao/reactor-local",
+  "@powerhousedao/reactor-mcp",
+  "@powerhousedao/switchboard-gui",
+  "@powerhousedao/vetra"
+];
+var CLIS_DEPENDENCIES = ["ph-cmd", "@powerhousedao/ph-cli"];
+var APPS_DEPENDENCIES = [
+  "@powerhousedao/connect",
+  "@powerhousedao/switchboard"
+];
+var ALL_POWERHOUSE_DEPENDENCIES = [
+  ...PACKAGES_DEPENDENCIES,
+  ...CLIS_DEPENDENCIES,
+  ...APPS_DEPENDENCIES
+];
+
+// src/utils/dependencies.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+
+// src/utils/package-manager.ts
+import { createProject } from "@powerhousedao/codegen";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import path3, { dirname } from "path";
+
+// src/utils/parsing.ts
+import chalk from "chalk";
+function parseTag(args) {
+  const { tag, dev, staging } = args;
+  if (tag) return tag;
+  if (dev) return "dev";
+  if (staging) return "staging";
+  return "latest";
+}
+function parsePackageManager(args) {
+  const { npm, pnpm, yarn, bun, packageManager } = args;
+  if (npm) return "npm";
+  if (pnpm) return "pnpm";
+  if (yarn) return "yarn";
+  if (bun) return "bun";
+  if (packageManager) return packageManager;
+  const userAgentPackageManager = process.env.npm_config_user_agent?.match(
+    /^(pnpm|npm|yarn|bun)\b/
+  )?.[1];
+  if (userAgentPackageManager) return userAgentPackageManager;
+  return void 0;
+}
+function handleMutuallyExclusiveOptions(options, optionsName) {
+  const mutuallyExclusiveOptions = Object.entries(options).map(([k, v]) => {
+    if (v !== void 0) return k;
+    return void 0;
+  }).filter((v) => v !== void 0);
+  if (mutuallyExclusiveOptions.length > 1) {
+    throw new Error(
+      `Cannot specify multiple ${optionsName} options. You provided: ${mutuallyExclusiveOptions.join(", ")}`
+    );
+  }
+}
+function getTagFromVersion(version) {
+  if (version.includes("dev")) return "dev";
+  if (version.includes("staging")) return "staging";
+  return "latest";
+}
+function logVersionUpdate(args) {
+  const { name, version, newVersion } = args;
+  console.log(
+    `\u2699\uFE0F Updating ${chalk.bold(name)}: ${chalk.blue(version)} -> ${chalk.green(newVersion)}`
+  );
+}
+
+// src/utils/package-manager.ts
+function defaultPathValidation() {
+  return true;
+}
+function isPowerhouseProject(dir) {
+  const powerhouseConfigPath = path3.join(dir, POWERHOUSE_CONFIG_FILE);
+  return existsSync2(powerhouseConfigPath);
+}
+function findNodeProjectRoot(dir, pathValidation = defaultPathValidation) {
+  const packageJsonPath = path3.join(dir, "package.json");
+  if (existsSync2(packageJsonPath) && pathValidation(dir)) {
+    return dir;
+  }
+  const parentDir = dirname(dir);
+  if (parentDir === dir) {
+    return null;
+  }
+  return findNodeProjectRoot(parentDir, pathValidation);
+}
+function getPackageManagerFromPath(dir) {
+  const lowerCasePath = dir.toLowerCase();
+  if (packageManagers.bun.globalPathRegexp.test(lowerCasePath)) {
+    return "bun";
+  } else if (packageManagers.pnpm.globalPathRegexp.test(lowerCasePath)) {
+    return "pnpm";
+  } else if (packageManagers.yarn.globalPathRegexp.test(lowerCasePath)) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getPackageManagerFromLockfile(dir) {
+  if (existsSync2(path3.join(dir, packageManagers.pnpm.lockfile))) {
+    return "pnpm";
+  } else if (existsSync2(path3.join(dir, packageManagers.yarn.lockfile))) {
+    return "yarn";
+  } else if (existsSync2(path3.join(dir, packageManagers.bun.lockfile))) {
+    return "bun";
+  }
+  return "npm";
+}
+async function getProjectInfo(debug, generateGlobalProject = true) {
+  const currentPath = process.cwd();
+  if (debug) {
+    console.log(">>> currentPath:", currentPath);
+  }
+  const projectPath = findNodeProjectRoot(currentPath, isPowerhouseProject);
+  if (!projectPath) {
+    let available = existsSync2(POWERHOUSE_GLOBAL_DIR);
+    if (generateGlobalProject) {
+      await createGlobalProject();
+      available = true;
+    }
+    return {
+      available,
+      isGlobal: true,
+      path: POWERHOUSE_GLOBAL_DIR
+    };
+  }
+  return {
+    isGlobal: false,
+    available: true,
+    path: projectPath
+  };
+}
+function forwardPHCommand(packageManager, projectPath, args, debug, captureOutput = false) {
+  const manager = packageManagers[packageManager];
+  const command5 = manager.execCommand;
+  const execCommand = command5.replace("{{arguments}}", args);
+  const commandOptions = { cwd: projectPath };
+  if (debug) {
+    console.log(">>> execCommand:", execCommand);
+    console.log(">>> commandOptions:", commandOptions);
+    console.log(">>> projectPath:", projectPath);
+    console.log(">>> packageManager:", packageManager);
+  }
+  if (captureOutput) {
+    try {
+      return execSync2(execCommand, {
+        stdio: "pipe",
+        encoding: "utf8",
+        ...commandOptions
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to execute command: ${execCommand}
+Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else {
+    execSync2(execCommand, {
+      stdio: "inherit",
+      ...commandOptions
+    });
+    return "";
+  }
+}
+var createGlobalProject = async (projectName, options = {}) => {
+  const globalProjectExists = existsSync2(POWERHOUSE_GLOBAL_DIR);
+  if (globalProjectExists) {
+    const packageJsonPath = path3.join(POWERHOUSE_GLOBAL_DIR, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(
+          readFileSync2(packageJsonPath, "utf-8")
+        );
+        if (packageJson.name?.startsWith(".")) {
+          console.log("\u{1F4E6} Fixing invalid package name in global project...");
+          packageJson.name = PH_GLOBAL_PACKAGE_NAME;
+          writeFileSync2(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        }
+      } catch {
+      }
+    }
+    console.log(`\u{1F4E6} Using global project: ${POWERHOUSE_GLOBAL_DIR}`);
+    return;
+  }
+  console.log("\u{1F4E6} Initializing global project...");
+  process.chdir(HOME_DIR);
+  try {
+    await createProject({
+      name: PH_GLOBAL_DIR_NAME,
+      tag: parseTag(options),
+      packageManager: parsePackageManager(options) ?? getPackageManagerFromPath(PH_BIN_PATH)
+    });
+    const packageJsonPath = path3.join(POWERHOUSE_GLOBAL_DIR, "package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    packageJson.name = PH_GLOBAL_PACKAGE_NAME;
+    writeFileSync2(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    console.log(
+      `\u{1F680} Global project initialized successfully: ${POWERHOUSE_GLOBAL_DIR}`
+    );
+  } catch (error) {
+    console.error("\u274C Failed to initialize the global project", error);
+  }
+};
+
+// src/utils/help-formatting.ts
+var HELP_FORMATTING_CONFIG = {
+  // Column width for command descriptions alignment
+  FIXED_COLUMN_WIDTH: 55,
+  // List of command names to apply padding to
+  COMMANDS_TO_PAD: ["setup-globals", "init", "use", "update", "help"],
+  // Padding to add before command descriptions for alignment
+  DESCRIPTION_PADDING: "            "
+};
+function extractCommandParts(line) {
+  let match = /^(\s+\S+(?:\|\S+)*(?:\s+\[options\])?(?:\s+\[[^\]]+\]|\s+<[^>]+>)*)(.*)$/.exec(
+    line
+  );
+  if (!match) {
+    match = /^(\s+\S+(?:\|\S+)*)(.*)$/.exec(line);
+  }
+  if (!match) {
+    return { cmd: line, desc: "" };
+  }
+  return {
+    cmd: match[1].trimEnd(),
+    desc: match[2].trim()
+  };
+}
+function formatCommandLine({ cmd, desc }, columnWidth) {
+  const padding = " ".repeat(Math.max(2, columnWidth - cmd.length));
+  return `${cmd}${padding}${desc}`;
+}
+function extractCommandLines(lines, startIndex) {
+  const commands2 = [];
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim() || !/^\s{2}\S/.exec(line)) {
+      break;
+    }
+    commands2.push(line);
+  }
+  return commands2;
+}
+function mergeHelp(cliHelp, forwardedHelp) {
+  const cliLines = cliHelp.split("\n");
+  const forwardedLines = forwardedHelp.split("\n");
+  const cliCommandsIndex = cliLines.findIndex(
+    (line) => line.trim() === "Commands:"
+  );
+  const forwardedCommandsIndex = forwardedLines.findIndex(
+    (line) => line.trim() === "Commands:"
+  );
+  const cliCommands = extractCommandLines(cliLines, cliCommandsIndex);
+  const forwardedCommands = extractCommandLines(
+    forwardedLines,
+    forwardedCommandsIndex
+  );
+  const cliCommandNames = /* @__PURE__ */ new Set();
+  cliCommands.forEach((line) => {
+    const match = /^\s+(\S+)(?:\|.*)?/.exec(line);
+    if (match) cliCommandNames.add(match[1]);
+  });
+  const uniqueForwardedCommands = forwardedCommands.filter((line) => {
+    const match = /^\s+(\S+)(?:\|.*)?/.exec(line);
+    if (!match) return false;
+    if (match[1] === "help") return false;
+    return !cliCommandNames.has(match[1]);
+  });
+  const cliParts = cliCommands.map(extractCommandParts);
+  const forwardedParts = uniqueForwardedCommands.map(extractCommandParts);
+  const formattedCliCommands = cliParts.map(
+    (parts) => formatCommandLine(parts, HELP_FORMATTING_CONFIG.FIXED_COLUMN_WIDTH)
+  );
+  const formattedForwardedCommands = forwardedParts.map(
+    (parts) => formatCommandLine(parts, HELP_FORMATTING_CONFIG.FIXED_COLUMN_WIDTH)
+  );
+  const headerSection = cliLines.slice(0, cliCommandsIndex + 1).join("\n");
+  return [
+    headerSection,
+    formattedCliCommands.join("\n"),
+    formattedForwardedCommands.join("\n")
+  ].join("\n");
+}
+function applyCommandPadding(program2) {
+  program2.commands.forEach((cmd) => {
+    if (HELP_FORMATTING_CONFIG.COMMANDS_TO_PAD.includes(cmd.name())) {
+      const desc = cmd.description();
+      cmd.description(HELP_FORMATTING_CONFIG.DESCRIPTION_PADDING + desc);
+    }
+  });
+}
+function restoreCommandDescriptions(program2) {
+  program2.commands.forEach((cmd) => {
+    if (HELP_FORMATTING_CONFIG.COMMANDS_TO_PAD.includes(cmd.name())) {
+      const desc = cmd.description();
+      cmd.description(desc.trim());
+    }
+  });
+}
+function captureCommanderHelp(program2) {
+  let helpText = "";
+  const originalConsoleLog = console.log;
+  console.log = (...args) => {
+    helpText += args.join(" ") + "\n";
+  };
+  program2.outputHelp();
+  console.log = originalConsoleLog;
+  return helpText;
+}
+var extraHelpLines = `
+  init [name] [options]                               Initialize a new project
+  use [release] [options]                             Specify your version of Powerhouse dependencies
+  update                                              Update your powerhouse dependencies
+`;
+function injectExtraHelpLines(helpText, extraLines) {
+  const result = `${extraLines}${helpText}`.replaceAll("\n\n", "").replace("\n", "");
+  return result;
+}
+async function generateMergedHelp(program2) {
+  const projectInfo = await getProjectInfo(void 0, false);
+  if (projectInfo.available) {
+    const packageManager = getPackageManagerFromLockfile(projectInfo.path);
+    const forwardedHelp = forwardPHCommand(
+      packageManager,
+      projectInfo.path,
+      "help",
+      void 0,
+      true
+    );
+    applyCommandPadding(program2);
+    const helpText = captureCommanderHelp(program2);
+    restoreCommandDescriptions(program2);
+    const mergedHelp = mergeHelp(helpText, forwardedHelp);
+    const withExtraLines = injectExtraHelpLines(mergedHelp, extraHelpLines);
+    console.log(withExtraLines);
+  } else {
+    console.log(captureCommanderHelp(program2));
+  }
+}
+
+// src/utils/help.ts
+function withHelpHandler(command5, actionFn) {
+  return (...args) => {
+    const rawArgs = process.argv;
+    const isHelpRequested = rawArgs.includes("--help") || rawArgs.includes("-h");
+    if (isHelpRequested) {
+      command5.outputHelp();
+      process.exit(0);
+    }
+    return actionFn(...args);
+  };
+}
+function withHelpAction(command5, actionFn, preCheck) {
+  command5.action(
+    withHelpHandler(command5, (...args) => {
+      if (preCheck) {
+        const result = preCheck(...args);
+        if (result === false) return;
+      }
+      return actionFn(...args);
+    })
+  );
+  return command5;
+}
+function withCustomHelp(command5, actionFn, helpText, preCheck) {
+  command5.helpInformation = function() {
+    const name = command5.name();
+    const args = command5.usage();
+    const description = command5.description();
+    let header = `
+Usage: ph ${name}`;
+    if (args) header += ` ${args}`;
+    if (description) header += `
+
+${description}
+`;
+    return header + "\n" + helpText;
+  };
+  return withHelpAction(command5, actionFn, preCheck);
+}
+
+// src/utils/validate-remote-drive.ts
+import {
+  createVetraDocument,
+  getVetraDocuments
+} from "@powerhousedao/common/utils";
+async function setupRemoteDrive(remoteDriveUrl) {
+  try {
+    const driveId = remoteDriveUrl.split("/").pop();
+    if (!remoteDriveUrl || remoteDriveUrl.trim() === "") {
+      console.error("\u274C Remote drive URL is required");
+      return false;
+    }
+    const url = new URL(remoteDriveUrl);
+    const graphqlEndpoint = `${url.protocol}//${url.host}/graphql`;
+    let documents = await getVetraDocuments(graphqlEndpoint, driveId);
+    if (documents.length === 0) {
+      console.log(
+        "No vetra package document found in the provided drive, creating one..."
+      );
+      try {
+        await createVetraDocument(graphqlEndpoint, driveId, "vetra-package");
+        documents = await getVetraDocuments(graphqlEndpoint, driveId);
+        if (documents.length === 0) {
+          console.error(
+            "\u274C Failed to create vetra package document in the remote drive"
+          );
+          return false;
+        }
+        console.log("\u2705 Vetra package document created successfully");
+      } catch (createError) {
+        console.error(
+          "\u274C Failed to create vetra package document:",
+          createError
+        );
+        return false;
+      }
+    }
+    if (documents.length > 1) {
+      console.warn(
+        "\u26A0\uFE0F  Multiple vetra package documents were found in the provided remote drive, this might be an error in your remote drive"
+      );
+    }
+    const hasGithubUrl = documents.some((doc) => doc.githubUrl);
+    if (hasGithubUrl) {
+      console.error(
+        "\u274C The remote drive provided already has been configured with a github url, please use the checkout command instead: ph checkout --remote-drive <remote drive url>"
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("\u274C Unable to fetch remote drive info:", error);
+    return false;
+  }
+}
+
+// src/commands/forward.ts
+var forwardCommand = async (args, options) => {
+  const argsList = args.split(" ");
+  const isHelpCommand = argsList.includes("help") || argsList.includes("--help") || argsList.includes("-h");
+  if (options.debug) {
+    console.log(">>> command arguments:", { options });
+  }
+  const projectInfo = await getProjectInfo(options.debug, !isHelpCommand);
+  if (options.debug) {
+    console.log("\n>>> projectInfo:", projectInfo);
+  }
+  const packageManager = getPackageManagerFromLockfile(projectInfo.path);
+  if (options.debug) {
+    console.log("\n>>> forwardCommand arguments:");
+    console.log(">>> packageManager:", packageManager);
+    console.log(">>> projectPath:", projectInfo.path);
+    console.log(">>> args:", args);
+  }
+  try {
+    if (isHelpCommand || options.logOutput) {
+      const helpOutput = forwardPHCommand(
+        packageManager,
+        projectInfo.path,
+        args,
+        options.debug,
+        true
+      );
+      console.log(helpOutput);
+    } else {
+      forwardPHCommand(packageManager, projectInfo.path, args, options.debug);
+    }
+  } catch (error) {
+    if (!args.length) {
+      return;
+    }
+    if (error.code === "ENOENT") {
+      console.error("Have you run `ph setup-globals` or `ph init`?");
+    }
+    if (options.debug) {
+      console.error("\u274C Failed to forward command");
+      throw error;
+    }
+  }
+};
+
+// src/commands/checkout.ts
+import { cloneRepository, installDependencies } from "@powerhousedao/codegen";
+
+// src/help.ts
+var setupGlobalsHelp = `
+Command Overview:
+  The setup-globals command initializes a new Powerhouse project with the necessary global 
+  configuration. It helps you set up a project quickly with proper defaults and dependencies.
+
+  This command:
+  1. Creates a new project with the specified name or in the current directory
+  2. Sets up all required Powerhouse dependencies
+  3. Configures the project with appropriate settings
+  4. Can run in interactive mode to guide you through the setup process
+
+Arguments:
+  [project-name]        Optional. Name of the project to create. If not provided,
+                        the command will use the current directory.
+
+Options:
+  -p, --project         Specify the name of the project to create.
+                        
+  -i, --interactive     Run the command in interactive mode, which will guide you
+                        through the setup process with questions and prompts.
+                        
+  -v, --version         Specify the development version to use. Defaults to "main".
+                        
+  --dev                 Use the "development" version of the boilerplate.
+                        
+  --staging             Use the "staging" version of the boilerplate.
+                        
+  --package-manager     Override the auto-detected package manager with the specified one.
+
+Project Structure:
+  The command will set up a project with the following structure:
+  - Proper configuration files for TypeScript and ESLint
+  - Dependencies for Powerhouse packages
+  - Build and development scripts
+
+Examples:
+  $ ph setup-globals my-project          # Create a new project named "my-project"
+  $ ph setup-globals                     # Set up a project in the current directory
+  $ ph setup-globals -i                  # Run setup in interactive mode
+  $ ph setup-globals --dev               # Use development version
+  $ ph setup-globals -v beta             # Use specific version
+  $ ph setup-globals --package-manager npm   # Use npm as package manager
+`;
+var checkoutHelp = `
+Command Overview:
+  The checkout command clones an existing Powerhouse project from a remote Vetra drive.
+  This allows you to work on projects that have been initialized and configured by others.
+
+  This command:
+  1. Fetches the GitHub repository URL from the specified Vetra remote drive
+  2. Clones the repository to your local machine
+  3. Installs all project dependencies
+
+Required Options:
+  -r, --remote-drive <url>   URL of the Vetra remote drive containing the project.
+                             The drive must have a Vetra package with a configured GitHub URL.
+
+Options:
+  --package-manager <pm>     Specify which package manager to use for installing dependencies.
+                             Supported: npm, yarn, pnpm, bun
+                             If not specified, uses the detected package manager from your environment.
+
+Examples:
+  $ ph checkout --remote-drive https://vetra.example.com/d/abc123                  # Clone project using default package manager
+  $ ph checkout --remote-drive https://vetra.example.com/d/abc123 --package-manager pnpm   # Clone and install with pnpm
+
+Notes:
+  - The remote drive must contain a Vetra package document with a GitHub URL configured
+  - If no GitHub URL is found, you'll need to use 'ph init --remote-drive' instead to create a new project
+  - The repository will be cloned into a directory named after the repository
+`;
+
+// src/utils/validate-remote-drive-checkout.ts
+import { getVetraDocuments as getVetraDocuments2 } from "@powerhousedao/common/utils";
+async function getPackageDocument(remoteDriveUrl) {
+  try {
+    const driveId = remoteDriveUrl.split("/").pop();
+    const url = new URL(remoteDriveUrl);
+    const graphqlEndpoint = `${url.protocol}//${url.host}/graphql`;
+    if (!driveId) {
+      return {
+        isValid: false,
+        error: "\u274C Invalid remote drive URL: unable to extract drive ID"
+      };
+    }
+    const documents = await getVetraDocuments2(graphqlEndpoint, driveId);
+    if (documents.length === 0) {
+      return {
+        isValid: false,
+        error: "\u274C No Vetra package documents found in the remote drive. Use 'ph init --remote-drive' to create a new project first."
+      };
+    }
+    const documentsWithUrl = documents.filter((doc) => doc.githubUrl);
+    if (documentsWithUrl.length === 0) {
+      return {
+        isValid: false,
+        error: "\u274C No GitHub URL configured in the Vetra package. Use 'ph init --remote-drive' to create a new project first."
+      };
+    }
+    if (documents.length > 1) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Multiple Vetra package documents found (${documents.length}). Using first document with GitHub URL.`
+      );
+    }
+    return {
+      isValid: true,
+      githubUrl: documentsWithUrl[0].githubUrl
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      error: `\u274C Unable to fetch remote drive info: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/commands/checkout.ts
+var checkout = async (options) => {
+  console.log("Checking out project from remote drive...");
+  try {
+    const packageDocument = await getPackageDocument(options.remoteDrive);
+    if (!packageDocument.isValid) {
+      console.error(packageDocument.error);
+      process.exit(1);
+    }
+    const projectPath = cloneRepository(packageDocument.githubUrl);
+    const detectedPackageManager = getPackageManagerFromLockfile(projectPath);
+    const packageManager = options.packageManager ?? detectedPackageManager;
+    installDependencies(projectPath, packageManager);
+    console.log("\x1B[32m", "Checkout completed successfully!", "\x1B[0m");
+  } catch (error) {
+    console.error(
+      "Failed to checkout the project",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+};
+function checkoutCommand(program2) {
+  const checkoutCmd = program2.command("checkout").description("Checkout an existing project from a remote drive").requiredOption(
+    "-r, --remote-drive <remoteDrive>",
+    "Remote drive identifier"
+  ).option("--package-manager <packageManager>", "Package manager to use");
+  return withCustomHelp(checkoutCmd, checkout, checkoutHelp);
+}
+
+// src/commands/help.ts
+function helpCommand(program2) {
+  program2.command("help").description("Display help information").action(async () => {
+    await generateMergedHelp(program2);
+  });
+}
+
+// src/commands/setup-globals.ts
+var setupGlobals = async (projectName, options) => {
+  await createGlobalProject(projectName, options);
+};
+function setupGlobalsCommand(program2) {
+  const setupGlobalsCmd = program2.command("setup-globals").description("Initialize a new global project").argument("[project-name]", "Name of the project").option("-p, --project", "Name of the project").option("-i, --interactive", "Run the command in interactive mode").option(
+    "-t, --tag",
+    'Specify development version to use. Defaults to "main"'
+  ).option("--dev", 'Use "development" version of the boilerplate').option("--staging", 'Use "development" version of the boilerplate').option("--package-manager <packageManager>", "package manager to be used").option("--npm", "Use 'npm' as package manager").option("--pnpm", "Use 'pnpm' as package manager").option("--yarn", "Use 'yarn' as package manager").option("--bun", "Use 'bun' as package manager");
+  return withCustomHelp(
+    setupGlobalsCmd,
+    setupGlobals,
+    setupGlobalsHelp
+  );
+}
+
+// src/commands/version.ts
+import fs from "fs";
+import path4 from "path";
+var customVersionHandler = async () => {
+  const projectInfo = await getProjectInfo(void 0, false);
+  const { version } = await import("./version-RL3XZD32.js");
+  console.log("PH CMD version: ", version);
+  if (projectInfo.available) {
+    const packageManager = getPackageManagerFromLockfile(projectInfo.path);
+    try {
+      const packageJsonPath = path4.join(projectInfo.path, "package.json");
+      const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const phCliVersion = packageJson.dependencies?.["@powerhousedao/ph-cli"] || packageJson.devDependencies?.["@powerhousedao/ph-cli"];
+      if (phCliVersion) {
+        console.log("PH CLI version: ", phCliVersion);
+      }
+    } catch (err) {
+      console.log(
+        "Error reading PH CLI version from package.json:",
+        err.message
+      );
+    }
+    console.log("-------------------------------------");
+    console.log("PH CLI path: ", projectInfo.path);
+    console.log("PH CLI isGlobalProject: ", projectInfo.isGlobal);
+    console.log("PH CLI packageManager: ", packageManager);
+  } else {
+    console.log("-------------------------------------");
+    console.log(
+      "PH CLI is not available, please run `ph setup-globals` to generate the default global project"
+    );
+  }
+};
+function versionOption(program2) {
+  return program2.option(
+    "-v, --version",
+    "Display version information",
+    customVersionHandler
+  );
+}
+
+// src/commands/index.ts
+var commands = [
+  setupGlobalsCommand,
+  checkoutCommand,
+  helpCommand,
+  versionOption
+];
+function registerCommands(program2) {
+  commands.forEach((command5) => command5(program2));
+}
+
+// src/commands/init.ts
+import { createProject as createProject2 } from "@powerhousedao/codegen";
+import chalk2 from "chalk";
+import { kebabCase } from "change-case";
+import {
+  boolean,
+  command,
+  flag,
+  oneOf,
+  option,
+  optional,
+  positional,
+  run,
+  string
+} from "cmd-ts";
+import enquirer from "enquirer";
+import { clean, valid } from "semver";
+var commandParser = command({
+  name: "ph init",
+  description: "Initialize a new project",
+  args: {
+    namePositional: positional({
+      type: optional(string),
+      displayName: "name",
+      description: "The name of your project. A new directory will be created in your current directory with this name."
+    }),
+    nameOption: option({
+      type: optional(string),
+      long: "name",
+      short: "n",
+      description: "The name of your project. A new directory will be created in your current directory with this name."
+    }),
+    packageManager: option({
+      type: optional(oneOf(["npm", "pnpm", "yarn", "bun"])),
+      long: "package-manager",
+      short: "p",
+      description: "Specify the package manager to use for your project. Can be one of: `npm`, `pnpm`, `yarn`, or `bun`. Defaults to your environment package manager."
+    }),
+    npm: flag({
+      type: optional(boolean),
+      long: "npm",
+      description: "Use 'npm' as package manager"
+    }),
+    pnpm: flag({
+      type: optional(boolean),
+      long: "pnpm",
+      description: "Use 'pnpm' as package manager"
+    }),
+    yarn: flag({
+      type: optional(boolean),
+      long: "yarn",
+      description: "Use 'yarn' as package manager"
+    }),
+    bun: flag({
+      type: optional(boolean),
+      long: "bun",
+      description: "Use 'bun' as package manager"
+    }),
+    tag: option({
+      type: optional(oneOf(["latest", "staging", "dev"])),
+      long: "tag",
+      short: "t",
+      description: `Specify the release tag to use for your project. Can be one of: "latest", "staging", or "dev".`
+    }),
+    version: option({
+      type: optional(string),
+      long: "version",
+      short: "v",
+      description: "Specify the exact semver release version to use for your project."
+    }),
+    dev: flag({
+      type: optional(boolean),
+      long: "dev",
+      short: "d",
+      description: "Use the `dev` release tag."
+    }),
+    staging: flag({
+      type: optional(boolean),
+      long: "staging",
+      short: "s",
+      description: "Use the `staging` release tag."
+    }),
+    remoteDrive: option({
+      type: optional(string),
+      long: "remote-drive",
+      short: "r",
+      description: "Remote drive identifier."
+    })
+  },
+  handler: async ({
+    namePositional,
+    nameOption,
+    packageManager,
+    npm,
+    pnpm,
+    yarn,
+    bun,
+    tag,
+    version,
+    dev,
+    staging,
+    remoteDrive
+  }) => {
+    let name = namePositional ?? nameOption;
+    if (!name) {
+      const { prompt } = enquirer;
+      const result = await prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "What is the project name?",
+          required: true,
+          result: (value) => kebabCase(value)
+        }
+      ]);
+      name = result.name;
+    }
+    if (!name) {
+      throw new Error("You must provide a name for your project.");
+    }
+    if (version !== void 0 && !valid(clean(version))) {
+      throw new Error(`Invalid version: ${version}`);
+    }
+    handleMutuallyExclusiveOptions(
+      {
+        tag,
+        version,
+        dev,
+        staging
+      },
+      "versioning strategy"
+    );
+    handleMutuallyExclusiveOptions(
+      {
+        npm,
+        pnpm,
+        yarn,
+        bun,
+        packageManager
+      },
+      "package manager"
+    );
+    const parsedPackageManager = parsePackageManager({
+      npm,
+      pnpm,
+      yarn,
+      bun,
+      packageManager
+    }) ?? "npm";
+    const parsedTag = parseTag({
+      tag,
+      dev,
+      staging
+    });
+    return {
+      name,
+      version,
+      remoteDrive,
+      packageManager: parsedPackageManager,
+      tag: parsedTag
+    };
+  }
+});
+async function init(args) {
+  try {
+    const parsedArgs = await run(commandParser, args);
+    const { name, remoteDrive } = parsedArgs;
+    if (remoteDrive) {
+      console.log(chalk2.blue("\n\u23F3 Setting up remote drive...\n"));
+      await setupRemoteDrive(remoteDrive);
+      console.log(chalk2.green("\n\u2705 Remote drive set up."));
+    }
+    console.log(chalk2.bold("\n\u{1F680} Initializing a new project...\n"));
+    await createProject2(parsedArgs);
+    if (remoteDrive) {
+      console.log();
+      console.log("To link your project to GitHub:");
+      console.log();
+      console.log("  1. Create a new repository on GitHub");
+      console.log(`  2. cd ${name}`);
+      console.log("  3. git add . && git commit -m 'Initial commit'");
+      console.log("  4. git remote add origin <your-github-url>");
+      console.log(`  5. git push -u origin main`);
+      console.log();
+    }
+  } catch (error) {
+    console.error("\n\u274C Failed to initialize project: \n");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+import { getPackageVersion } from "@powerhousedao/codegen/utils";
+import chalk3 from "chalk";
+import { boolean as boolean2, command as command2, flag as flag2, optional as optional2, run as run2 } from "cmd-ts";
+import { detect } from "package-manager-detector/detect";
+import { readPackage } from "read-pkg";
+import { writePackage } from "write-package";
+
+// src/utils/run-cmd.ts
+import { execSync as execSync3 } from "child_process";
+function runCmd(command5) {
+  try {
+    execSync3(command5, { stdio: "inherit" });
+  } catch (error) {
+    console.log("\x1B[31m", error, "\x1B[0m");
+    throw error;
+  }
+}
+
+// src/commands/update.ts
+var commandParser2 = command2({
+  name: "ph update",
+  description: "Update your powerhouse dependencies to their latest tagged version",
+  args: {
+    skipInstall: flag2({
+      type: optional2(boolean2),
+      long: "skip-install",
+      short: "s",
+      description: "Skip running `install` with your package manager"
+    })
+  },
+  handler: async ({ skipInstall }) => {
+    console.log(`
+\u25B6\uFE0F Updating Powerhouse dependencies...
+`);
+    const packageJson = await readPackage();
+    if (packageJson.dependencies) {
+      for (const [name, version] of Object.entries(packageJson.dependencies)) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const tag = getTagFromVersion(version);
+          const newVersion = await getPackageVersion({ name, tag });
+          packageJson.dependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.devDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.devDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const tag = getTagFromVersion(version);
+          const newVersion = await getPackageVersion({ name, tag });
+          packageJson.devDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.optionalDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.optionalDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const tag = getTagFromVersion(version);
+          const newVersion = await getPackageVersion({ name, tag });
+          packageJson.optionalDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.peerDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.peerDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const tag = getTagFromVersion(version);
+          const newVersion = await getPackageVersion({ name, tag });
+          packageJson.peerDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    await writePackage(packageJson);
+    console.log(chalk3.green(`
+\u2705 Project updated successfully
+`));
+    if (skipInstall) return;
+    const packageManager = await detect();
+    if (!packageManager) {
+      throw new Error(
+        `\u274C Failed to detect your package manager. Run install manually.`
+      );
+    }
+    console.log(
+      `\u25B6\uFE0F Installing updated dependencies with \`${packageManager.agent}\`
+`
+    );
+    runCmd(`${packageManager.agent} install`);
+  }
+});
+async function update(args) {
+  await run2(commandParser2, args);
+}
+
+// src/commands/use-local.ts
+import chalk4 from "chalk";
+import {
+  boolean as boolean3,
+  command as command3,
+  flag as flag3,
+  option as option2,
+  optional as optional3,
+  positional as positional2,
+  run as run3,
+  string as string2
+} from "cmd-ts";
+import path5 from "path";
+import { readPackage as readPackage2 } from "read-pkg";
+import { writePackage as writePackage2 } from "write-package";
+
+// src/utils/file-system.ts
+import { constants } from "fs";
+import { access } from "fs/promises";
+async function dirExists(path6) {
+  try {
+    await access(path6, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/use-local.ts
+var commandParser3 = command3({
+  name: "ph use-local",
+  description: "Use your local `powerhouse` monorepo dependencies the current project. NOTE: The monorepo uses `pnpm`, so this only works with `pnpm`.",
+  args: {
+    monorepoPathPositional: positional2({
+      type: optional3(string2),
+      displayName: "monorepo path",
+      description: "Path to your local powerhouse monorepo relative to this project"
+    }),
+    monorepoPathOption: option2({
+      type: optional3(string2),
+      long: "path",
+      short: "p",
+      description: "Path to your local powerhouse monorepo relative to this project"
+    }),
+    skipInstall: flag3({
+      type: optional3(boolean3),
+      long: "skip-install",
+      short: "s",
+      description: "Skip running `install` with `pnpm`"
+    })
+  },
+  handler: async ({
+    monorepoPathPositional,
+    monorepoPathOption,
+    skipInstall
+  }) => {
+    const monorepoPath = monorepoPathPositional ?? monorepoPathOption;
+    if (!monorepoPath) {
+      throw new Error(
+        "\u274C Please provide the path to your local powerhouse monorepo."
+      );
+    }
+    const monorepoDirExists = await dirExists(monorepoPath);
+    if (!monorepoDirExists) {
+      throw new Error(
+        "\u274C No directory found at the powerhouse monorepo path you specified."
+      );
+    }
+    console.log(
+      `
+\u25B6\uFE0F Linking powerhouse dependencies to "${chalk4.bold(monorepoPath)}...
+`
+    );
+    const packageJson = await readPackage2();
+    if (packageJson.dependencies) {
+      for (const [name, version] of Object.entries(packageJson.dependencies)) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = buildPnpmLink(name, monorepoPath);
+          packageJson.dependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.devDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.devDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = buildPnpmLink(name, monorepoPath);
+          packageJson.devDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.optionalDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.optionalDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = buildPnpmLink(name, monorepoPath);
+          packageJson.optionalDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.peerDependencies) {
+      for (const [name, version] of Object.entries(
+        packageJson.peerDependencies
+      )) {
+        if (version && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = buildPnpmLink(name, monorepoPath);
+          packageJson.peerDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version,
+            newVersion
+          });
+        }
+      }
+    }
+    await writePackage2(packageJson);
+    console.log(chalk4.green(`
+\u2705 Project linked successfully
+`));
+    if (skipInstall) return;
+    console.log(`Installing linked dependencies with \`pnpm\`
+`);
+    runCmd(`pnpm install`);
+  }
+});
+function buildPnpmLink(packageName, monorepoPath) {
+  const isCli = CLIS_DEPENDENCIES.includes(packageName);
+  const isApp = APPS_DEPENDENCIES.includes(packageName);
+  const packageDir = isCli ? "clis" : isApp ? "apps" : "packages";
+  const packageNameWithoutNamespace = packageName.replace(
+    "@powerhousedao/",
+    ""
+  );
+  const packagePath = path5.join(
+    monorepoPath,
+    packageDir,
+    packageNameWithoutNamespace
+  );
+  const pnpmLink = `link:${packagePath}`;
+  return pnpmLink;
+}
+async function useLocal(args) {
+  await run3(commandParser3, args);
+}
+
+// src/commands/use.ts
+import { getPackageVersion as getPackageVersion2 } from "@powerhousedao/codegen/utils";
+import chalk5 from "chalk";
+import {
+  boolean as boolean4,
+  command as command4,
+  flag as flag4,
+  oneOf as oneOf2,
+  option as option3,
+  optional as optional4,
+  positional as positional3,
+  run as run4,
+  string as string3
+} from "cmd-ts";
+import { detect as detect2 } from "package-manager-detector/detect";
+import { readPackage as readPackage3 } from "read-pkg";
+import { clean as clean2, valid as valid2 } from "semver";
+import { writePackage as writePackage3 } from "write-package";
+var commandParser4 = command4({
+  name: "ph use",
+  description: "Specify the release version of Powerhouse dependencies to use.\nTo use a release tag, specify `staging`, `dev`, or `latest` as the first argument to this command or with the --tag option.\n You can also use a specific version with the --version option.",
+  args: {
+    tagPositional: positional3({
+      type: optional4(oneOf2(["latest", "staging", "dev"])),
+      displayName: "tag",
+      description: `Specify the release tag to use for your project. Can be one of: "latest", "staging", or "dev".`
+    }),
+    tagOption: option3({
+      type: optional4(oneOf2(["latest", "staging", "dev"])),
+      long: "tag",
+      short: "t",
+      description: `Specify the release tag to use for your project. Can be one of: "latest", "staging", or "dev".`
+    }),
+    version: option3({
+      type: optional4(string3),
+      long: "version",
+      short: "v",
+      description: "Specify the exact semver release version to use for your project."
+    }),
+    skipInstall: flag4({
+      type: optional4(boolean4),
+      long: "skip-install",
+      short: "s",
+      description: "Skip running `install` with your package manager"
+    })
+  },
+  handler: async ({ tagPositional, tagOption, version, skipInstall }) => {
+    const tag = tagPositional ?? tagOption;
+    handleMutuallyExclusiveOptions({ tag, version }, "versioning strategy");
+    if (!tag && !version) {
+      throw new Error(
+        "Please specify either a release tag or a version to use."
+      );
+    }
+    if (version && !valid2(clean2(version))) {
+      throw new Error(`\u274C Invalid version: ${chalk5.bold(version)}`);
+    }
+    console.log(
+      `\u25B6\uFE0F Updating project to use ${chalk5.bold(version ?? tag)}...
+`
+    );
+    const packageJson = await readPackage3();
+    if (packageJson.dependencies) {
+      for (const [name, existingVersion] of Object.entries(
+        packageJson.dependencies
+      )) {
+        if (existingVersion && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = await getPackageVersion2({ name, tag, version });
+          packageJson.dependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version: existingVersion,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.devDependencies) {
+      for (const [name, existingVersion] of Object.entries(
+        packageJson.devDependencies
+      )) {
+        if (existingVersion && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = await getPackageVersion2({ name, tag, version });
+          packageJson.devDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version: existingVersion,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.optionalDependencies) {
+      for (const [name, existingVersion] of Object.entries(
+        packageJson.optionalDependencies
+      )) {
+        if (existingVersion && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = await getPackageVersion2({ name, tag, version });
+          packageJson.optionalDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version: existingVersion,
+            newVersion
+          });
+        }
+      }
+    }
+    if (packageJson.peerDependencies) {
+      for (const [name, existingVersion] of Object.entries(
+        packageJson.peerDependencies
+      )) {
+        if (existingVersion && ALL_POWERHOUSE_DEPENDENCIES.includes(name)) {
+          const newVersion = await getPackageVersion2({ name, tag, version });
+          packageJson.peerDependencies[name] = newVersion;
+          logVersionUpdate({
+            name,
+            version: existingVersion,
+            newVersion
+          });
+        }
+      }
+    }
+    await writePackage3(packageJson);
+    console.log(
+      chalk5.green(
+        `
+\u2705 Project updated to use ${chalk5.bold(version ?? tag)}
+`
+      )
+    );
+    if (skipInstall) return;
+    const packageManager = await detect2();
+    if (!packageManager) {
+      throw new Error(
+        `\u274C Failed to detect your package manager. Run install manually.`
+      );
+    }
+    console.log(
+      `\u25B6\uFE0F Installing updated dependencies with \`${packageManager.agent}\`
+`
+    );
+    runCmd(`${packageManager.agent} install`);
+  }
+});
+async function use(args) {
+  await run4(commandParser4, args);
+}
+
+// src/cli.ts
+function ensureNodeVersion(minVersion = "22") {
+  const version = process.versions.node;
+  if (!version) {
+    return;
+  }
+  if (version < minVersion) {
+    console.error(
+      `Node version ${minVersion} or higher is required. Current version: ${version}`
+    );
+    process.exit(1);
+  }
+}
+ensureNodeVersion("22");
+var program = new Command();
+var helpShown = false;
+async function customHelpHandler() {
+  if (helpShown) return;
+  helpShown = true;
+  await generateMergedHelp(program);
+  process.exit(0);
+}
+var defaultCommand = async (options) => {
+  const allArgs = process.argv.slice(2);
+  const args = allArgs.join(" ");
+  const firstPositionalArg = allArgs[0];
+  const isInit = firstPositionalArg === "init";
+  if (isInit) {
+    await init(process.argv.slice(3));
+    process.exit(0);
+  }
+  const isUpdate = firstPositionalArg === "update";
+  if (isUpdate) {
+    await update(process.argv.slice(3));
+    process.exit(0);
+  }
+  const isUse = firstPositionalArg === "use";
+  if (isUse) {
+    await use(process.argv.slice(3));
+    process.exit(0);
+  }
+  const isUseLocal = firstPositionalArg === "use-local";
+  if (isUseLocal) {
+    await useLocal(process.argv.slice(3));
+    process.exit(0);
+  }
+  const isHelpCommand = args.startsWith("--help") || args.startsWith("-h");
+  const isVersionCommand = args.startsWith("--version") || args.startsWith("-v") || args.startsWith("version");
+  if (!args.length) {
+    program.parse(process.argv.concat("--help"));
+    process.exit(0);
+  }
+  if (!isHelpCommand && !isVersionCommand) {
+    forwardCommand(args, { debug: !!options.verbose }).catch(
+      (error) => {
+        if (typeof error === "string" || options.verbose) {
+          console.error(error);
+        } else if (error instanceof Error) {
+          console.error(error.message);
+        }
+        process.exit(1);
+      }
+    );
+  }
+};
+program.name("ph").description(
+  "The Powerhouse CLI (ph-cmd) is a command-line interface tool that provides essential commands for managing Powerhouse projects. The tool and it's commands are fundamental for creating, building, and running Document Models as a builder in studio mode."
+).allowUnknownOption().option("--verbose, --debug", "Enable debug mode").option("-h, --help", "Display help information");
+registerCommands(program);
+program.action(defaultCommand);
+program.on("option:help", () => {
+  const nonHelpArgs = process.argv.slice(2).filter((arg) => arg !== "--help" && arg !== "-h");
+  if (nonHelpArgs.length === 0) {
+    customHelpHandler().catch((error) => {
+      console.error(error);
+      process.exit(1);
+    });
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  const isDebug = process.argv.find(
+    (arg) => ["--verbose", "--debug"].includes(arg)
+  );
+  if (isDebug) {
+    console.error(error);
+    return;
+  }
+  const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error, null, 2);
+  console.error(errorMessage);
+});