@iloom/cli 0.1.14

package/dist/cli.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+import {
+  ShellCompletion
+} from "./chunk-O2QWO64Z.js";
+import {
+  GitWorktreeManager
+} from "./chunk-QEPVTTHD.js";
+import "./chunk-JQ7VOSTC.js";
+import {
+  logger
+} from "./chunk-GEHQXLEI.js";
+
+// src/cli.ts
+import { program, Option } from "commander";
+
+// src/utils/package-info.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function getPackageInfo(scriptPath) {
+  try {
+    let basePath;
+    if (scriptPath) {
+      basePath = scriptPath;
+    } else {
+      const __filename2 = fileURLToPath(import.meta.url);
+      basePath = __filename2;
+    }
+    const __dirname = dirname(basePath);
+    const packageJsonPath = join(__dirname, "..", "package.json");
+    const packageJsonContent = readFileSync(packageJsonPath, "utf8");
+    const packageJson2 = JSON.parse(packageJsonContent);
+    return packageJson2;
+  } catch (error) {
+    throw new Error(
+      `Failed to read package.json: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/cli.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var packageJson = getPackageInfo(__filename);
+program.name("iloom").description(packageJson.description).version(packageJson.version).option("--debug", "Enable debug output (default: based on ILOOM_DEBUG env var)").option("--completion", "Output shell completion script for current shell").option("--set <key=value>", "Override any setting using dot notation (repeatable, e.g., --set workflows.issue.startIde=false)").allowUnknownOption().hook("preAction", async (thisCommand) => {
+  const options = thisCommand.opts();
+  const envDebug = process.env.ILOOM_DEBUG === "true";
+  const debugEnabled = options.debug !== void 0 ? options.debug : envDebug;
+  logger.setDebug(debugEnabled);
+  if (options.completion) {
+    const shellCompletion2 = new ShellCompletion();
+    shellCompletion2.printCompletionScript();
+    process.exit(0);
+  }
+  try {
+    const { checkAndNotifyUpdate } = await import("./update-notifier-QSSEB5KC.js");
+    const { detectInstallationMethod } = await import("./installation-detector-VARGFFRZ.js");
+    const installMethod = detectInstallationMethod(__filename);
+    await checkAndNotifyUpdate(packageJson.version, packageJson.name, installMethod);
+  } catch {
+  }
+  try {
+    const { SettingsMigrationManager } = await import("./SettingsMigrationManager-MTQIMI54.js");
+    const migrationManager = new SettingsMigrationManager();
+    await migrationManager.migrateSettingsIfNeeded();
+  } catch (error) {
+    logger.debug(`Settings migration failed: ${error instanceof Error ? error.message : "Unknown"}`);
+  }
+  await validateSettingsForCommand();
+});
+async function validateSettingsForCommand() {
+  try {
+    const { SettingsManager } = await import("./SettingsManager-VAZF26S2.js");
+    const settingsManager = new SettingsManager();
+    await settingsManager.loadSettings();
+  } catch (error) {
+    logger.error(`Configuration error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    logger.info("Please fix your .iloom/settings.json file and try again.");
+    process.exit(1);
+  }
+}
+var shellCompletion = new ShellCompletion();
+shellCompletion.init();
+program.command("start").alias("create").alias("up").description("Create isolated workspace for an issue/PR").argument("[identifier]", "Issue number, PR number, or branch name (optional - will prompt if not provided)").option("--claude", "Enable Claude integration (default: true)").option("--no-claude", "Disable Claude integration").option("--code", "Enable VSCode (default: true)").option("--no-code", "Disable VSCode").option("--dev-server", "Enable dev server in terminal (default: true)").option("--no-dev-server", "Disable dev server").option("--terminal", "Enable terminal without dev server (default: false)").option("--no-terminal", "Disable terminal").addOption(
+  new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
+).action(async (identifier, options) => {
+  try {
+    let finalIdentifier = identifier;
+    if (!finalIdentifier) {
+      const { promptInput } = await import("./prompt-ANTQWHUF.js");
+      finalIdentifier = await promptInput("Enter issue number, PR number (pr/123), or branch name");
+      if (!(finalIdentifier == null ? void 0 : finalIdentifier.trim())) {
+        logger.error("Identifier is required");
+        process.exit(1);
+      }
+    }
+    const { StartCommand } = await import("./start-LWVRBJ6S.js");
+    const command = new StartCommand();
+    await command.execute({ identifier: finalIdentifier, options });
+  } catch (error) {
+    logger.error(`Failed to start workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("add-issue").alias("a").description("Create and enhance GitHub issue without starting workspace").argument("<description>", "Natural language description of the issue (>50 chars, >2 spaces)").action(async (description) => {
+  try {
+    const { AddIssueCommand } = await import("./add-issue-22JBNOML.js");
+    const command = new AddIssueCommand();
+    const issueNumber = await command.execute({
+      description,
+      options: {}
+    });
+    logger.success(`Issue #${issueNumber} created successfully`);
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("feedback").alias("f").description("Submit feedback/bug report to iloom-cli repository").argument("<description>", "Natural language description of feedback (>50 chars, >2 spaces)").action(async (description) => {
+  try {
+    const { FeedbackCommand } = await import("./feedback-23CLXKFT.js");
+    const command = new FeedbackCommand();
+    const issueNumber = await command.execute({
+      description,
+      options: {}
+    });
+    logger.success(`Feedback submitted as issue #${issueNumber} in iloom-cli repository`);
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Failed to submit feedback: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("enhance").description("Apply enhancement agent to existing GitHub issue").argument("<issue-number>", "GitHub issue number to enhance", parseInt).option("--no-browser", "Skip browser opening prompt").option("--author <username>", "GitHub username to tag in questions (for CI usage)").action(async (issueNumber, options) => {
+  try {
+    const { EnhanceCommand } = await import("./enhance-XJIQHVPD.js");
+    const command = new EnhanceCommand();
+    await command.execute({
+      issueNumber,
+      options: {
+        noBrowser: options.browser === false,
+        ...options.author && { author: options.author }
+      }
+    });
+    logger.success(`Enhancement process completed for issue #${issueNumber}`);
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Failed to enhance issue: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("finish").alias("dn").description("Merge work and cleanup workspace").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").option("-f, --force", "Skip confirmation prompts").option("-n, --dry-run", "Preview actions without executing").option("--pr <number>", "Treat input as PR number", parseFloat).option("--skip-build", "Skip post-merge build verification").action(async (identifier, options) => {
+  try {
+    const { FinishCommand } = await import("./finish-CY4CIH6O.js");
+    const command = new FinishCommand();
+    await command.execute({ identifier, options });
+  } catch (error) {
+    logger.error(`Failed to finish workspace: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("spin").alias("ignite").description("Launch Claude with auto-detected workspace context").addOption(
+  new Option("--one-shot <mode>", "One-shot automation mode").choices(["default", "noReview", "bypassPermissions"]).default("default")
+).action(async (options) => {
+  try {
+    const { IgniteCommand } = await import("./ignite-WXEF2ID5.js");
+    const command = new IgniteCommand();
+    await command.execute(options.oneShot ?? "default");
+  } catch (error) {
+    logger.error(`Failed to spin up loom: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("open").description("Open workspace in browser or run CLI tool").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
+  try {
+    const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
+    const { OpenCommand } = await import("./open-X6BTENPV.js");
+    const cmd = new OpenCommand();
+    const input = identifier ? { identifier, args } : { args };
+    await cmd.execute(input);
+  } catch (error) {
+    logger.error(`Failed to open: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("run").description("Run CLI tool or open workspace in browser").argument("[identifier]", "Issue number, PR number, or branch name (auto-detected if omitted)").allowUnknownOption().action(async (identifier, _options, command) => {
+  try {
+    const args = (command == null ? void 0 : command.args) ? command.args.slice(identifier ? 1 : 0) : [];
+    const { RunCommand } = await import("./run-2JCPQAX3.js");
+    const cmd = new RunCommand();
+    const input = identifier ? { identifier, args } : { args };
+    await cmd.execute(input);
+  } catch (error) {
+    logger.error(`Failed to run: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("cleanup").description("Remove workspaces").argument("[identifier]", "Branch name or issue number to cleanup (auto-detected)").option("-l, --list", "List all worktrees").option("-a, --all", "Remove all worktrees (interactive confirmation)").option("-i, --issue <number>", "Cleanup by issue number", parseInt).option("-f, --force", "Skip confirmations and force removal").option("--dry-run", "Show what would be done without doing it").action(async (identifier, options) => {
+  try {
+    const { CleanupCommand } = await import("./cleanup-3LUWPSM7.js");
+    const command = new CleanupCommand();
+    const input = {
+      options: options ?? {}
+    };
+    if (identifier) {
+      input.identifier = identifier;
+    }
+    await command.execute(input);
+  } catch (error) {
+    logger.error(`Failed to cleanup worktrees: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("list").description("Show active workspaces").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const manager = new GitWorktreeManager();
+    const worktrees = await manager.listWorktrees({ porcelain: true });
+    if (options.json) {
+      console.log(JSON.stringify(worktrees, null, 2));
+      return;
+    }
+    if (worktrees.length === 0) {
+      logger.info("No worktrees found");
+      return;
+    }
+    logger.info("Active workspaces:");
+    for (const worktree of worktrees) {
+      const formatted = manager.formatWorktree(worktree);
+      logger.info(`  ${formatted.title}`);
+      logger.info(`    Path: ${formatted.path}`);
+      logger.info(`    Commit: ${formatted.commit}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to list worktrees: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize iloom configuration and setup shell autocomplete").action(async () => {
+  try {
+    const { InitCommand } = await import("./init-RHACUR4E.js");
+    const command = new InitCommand();
+    await command.execute();
+  } catch (error) {
+    logger.error(`Failed to initialize: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("update").description("Update iloom-cli to the latest version").option("--dry-run", "Show what would be done without actually updating").action(async (options) => {
+  try {
+    const { UpdateCommand } = await import("./update-3ZT2XX2G.js");
+    const command = new UpdateCommand();
+    await command.execute(options);
+  } catch (error) {
+    logger.error(`Failed to update: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+program.command("test-github").description("Test GitHub integration (Issue #3)").argument("<identifier>", "Issue number or PR number").option("--no-claude", "Skip Claude for branch name generation").action(async (identifier, options) => {
+  try {
+    const { GitHubService } = await import("./GitHubService-F7Z3XJOS.js");
+    logger.info("Testing GitHub Integration\n");
+    const service = new GitHubService(options.claude !== void 0 ? { useClaude: options.claude } : {});
+    logger.info("Detecting input type...");
+    const detection = await service.detectInputType(identifier);
+    logger.info(`   Type: ${detection.type}`);
+    logger.info(`   Number: ${detection.number}`);
+    if (detection.type === "unknown") {
+      logger.error("Could not detect if input is an issue or PR");
+      process.exit(1);
+    }
+    logger.info("Fetching from GitHub...");
+    if (detection.type === "issue") {
+      if (!detection.number) {
+        throw new Error("Issue number not detected");
+      }
+      const issue = await service.fetchIssue(detection.number);
+      logger.success(`   Issue #${issue.number}: ${issue.title}`);
+      logger.info(`   State: ${issue.state}`);
+      logger.info(`   Labels: ${issue.labels.join(", ") || "none"}`);
+      logger.info(`   URL: ${issue.url}`);
+      logger.info("Generating branch name...");
+      const branchName = await service.generateBranchName({
+        issueNumber: issue.number,
+        title: issue.title
+      });
+      logger.success(`   Branch: ${branchName}`);
+      logger.info("Extracting context for Claude...");
+      const context = service.extractContext(issue);
+      logger.info(`   ${context.split("\n").join("\n   ")}`);
+    } else {
+      if (!detection.number) {
+        throw new Error("PR number not detected");
+      }
+      const pr = await service.fetchPR(detection.number);
+      logger.success(`   PR #${pr.number}: ${pr.title}`);
+      logger.info(`   State: ${pr.state}`);
+      logger.info(`   Branch: ${pr.branch}`);
+      logger.info(`   Base: ${pr.baseBranch}`);
+      logger.info(`   URL: ${pr.url}`);
+      logger.info("Extracting context for Claude...");
+      const context = service.extractContext(pr);
+      logger.info(`   ${context.split("\n").join("\n   ")}`);
+    }
+    logger.success("All GitHub integration tests passed!");
+  } catch (error) {
+    logger.error(`Test failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-claude").description("Test Claude integration (Issue #10)").option("--detect", "Test Claude CLI detection").option("--version", "Get Claude CLI version").option("--branch <title>", "Test branch name generation with given title").option("--issue <number>", "Issue number for branch generation", "123").option("--launch <prompt>", "Launch Claude with a prompt (headless)").option("--interactive", "Launch Claude interactively (requires --launch)").option("--template <name>", "Test template loading").action(async (options) => {
+  try {
+    const { detectClaudeCli, getClaudeVersion, generateBranchName, launchClaude } = await import("./claude-7LUVDZZ4.js");
+    const { PromptTemplateManager } = await import("./PromptTemplateManager-7FINLRDE.js");
+    const { ClaudeService } = await import("./ClaudeService-YSZ6EXWP.js");
+    const { ClaudeContextManager } = await import("./ClaudeContextManager-XOSXQ67R.js");
+    logger.info("Testing Claude Integration\n");
+    if (options.detect) {
+      logger.info("Detecting Claude CLI...");
+      const isAvailable = await detectClaudeCli();
+      if (isAvailable) {
+        logger.success("   Claude CLI is available");
+      } else {
+        logger.error("   Claude CLI not found");
+      }
+    }
+    if (options.version) {
+      logger.info("Getting Claude version...");
+      const version = await getClaudeVersion();
+      if (version) {
+        logger.success(`   Version: ${version}`);
+      } else {
+        logger.error("   Could not get version");
+      }
+    }
+    if (options.branch) {
+      logger.info("Generating branch name...");
+      const issueNumber = parseInt(options.issue ?? "123");
+      logger.info(`   Issue #${issueNumber}: ${options.branch}`);
+      const branchName = await generateBranchName(options.branch, issueNumber);
+      logger.success(`   Generated: ${branchName}`);
+    }
+    if (options.launch) {
+      logger.info("Launching Claude...");
+      logger.info(`   Prompt: "${options.launch}"`);
+      logger.info(`   Mode: ${options.interactive ? "Interactive" : "Headless"}`);
+      if (options.interactive) {
+        logger.info("   Launching Claude in new terminal...");
+        await launchClaude(options.launch, { headless: false });
+        logger.info("   (Claude should open in a separate process)");
+      } else {
+        logger.info("   Waiting for response...");
+        const result = await launchClaude(options.launch, { headless: true });
+        if (result) {
+          logger.success("   Response:");
+          logger.info(`   ${result.split("\n").join("\n   ")}`);
+        }
+      }
+    }
+    if (options.template) {
+      logger.info("Loading template...");
+      logger.info(`   Template: ${options.template}`);
+      const manager = new PromptTemplateManager();
+      try {
+        const content = await manager.loadTemplate(options.template);
+        logger.success("   Template loaded successfully");
+        logger.info("   First 200 chars:");
+        logger.info(`   ${content.substring(0, 200).split("\n").join("\n   ")}...`);
+      } catch (error) {
+        logger.error(`   Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    if (!options.detect && !options.version && !options.branch && !options.launch && !options.template) {
+      logger.info("Running full Claude integration test suite...\n");
+      logger.info("1. Testing Claude CLI detection...");
+      const isAvailable = await detectClaudeCli();
+      if (isAvailable) {
+        logger.success("   Claude CLI is available");
+      } else {
+        logger.error("   Claude CLI not found");
+        logger.info("\nSkipping remaining tests since Claude CLI is not available");
+        return;
+      }
+      logger.info("\n2. Getting Claude version...");
+      const version = await getClaudeVersion();
+      if (version) {
+        logger.success(`   Version: ${version}`);
+      } else {
+        logger.error("   Could not get version");
+      }
+      logger.info("\n3. Testing branch name generation...");
+      const testIssueNumber = 123;
+      const testTitle = "Add user authentication feature";
+      logger.info(`   Issue #${testIssueNumber}: ${testTitle}`);
+      const branchName = await generateBranchName(testTitle, testIssueNumber);
+      logger.success(`   Generated: ${branchName}`);
+      logger.info("\n4. Testing ClaudeService initialization...");
+      new ClaudeService();
+      logger.success("   Service initialized");
+      logger.info("\n5. Testing ClaudeContextManager...");
+      const contextManager = new ClaudeContextManager();
+      await contextManager.prepareContext({
+        type: "issue",
+        identifier: 123,
+        title: "Test issue",
+        workspacePath: process.cwd(),
+        port: 3123
+      });
+      logger.success("   Context prepared");
+      logger.info("\n6. Testing template loading...");
+      const templateManager = new PromptTemplateManager();
+      const templates = ["issue", "pr", "regular"];
+      let templateCount = 0;
+      for (const template of templates) {
+        try {
+          await templateManager.loadTemplate(template);
+          logger.success(`   ${template} template loaded`);
+          templateCount++;
+        } catch {
+          logger.warn(`   ${template} template not found`);
+        }
+      }
+      logger.info(`   Loaded ${templateCount}/${templates.length} templates`);
+      logger.info("\n7. Testing Claude launch (headless)...");
+      logger.info('   Sending test prompt: "Say hello"');
+      try {
+        const result = await launchClaude("Say hello", { headless: true });
+        if (result) {
+          logger.success("   Claude responded successfully");
+          logger.info(`   Response preview: ${result.substring(0, 100)}...`);
+        } else {
+          logger.warn("   No response received");
+        }
+      } catch (error) {
+        logger.error(`   Launch failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      logger.info("\n" + "=".repeat(50));
+      logger.success("All Claude integration tests complete!");
+      logger.info("Summary: All core Claude features are working correctly");
+    }
+  } catch (error) {
+    logger.error(`Test failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-webserver").description("Test if a web server is running on a workspace port").argument("<issue-number>", "Issue number (port will be calculated as 3000 + issue number)", parseInt).option("--kill", "Kill the web server if detected").action(async (issueNumber, options) => {
+  try {
+    const { TestWebserverCommand } = await import("./test-webserver-M2I3EV4J.js");
+    const command = new TestWebserverCommand();
+    await command.execute({ issueNumber, options });
+  } catch (error) {
+    logger.error(`Test webserver failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-git").description("Test Git integration - findMainWorktreePath() function (reads .iloom/settings.json)").action(async () => {
+  try {
+    const { TestGitCommand } = await import("./test-git-XPF4SZXJ.js");
+    const command = new TestGitCommand();
+    await command.execute();
+  } catch (error) {
+    logger.error(`Test git failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-tabs").description("Test iTerm2 dual tab functionality - opens two tabs with test commands").action(async () => {
+  try {
+    const { TestTabsCommand } = await import("./test-tabs-JRKY3QMM.js");
+    const command = new TestTabsCommand();
+    await command.execute();
+  } catch (error) {
+    logger.error(`Test tabs failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-prefix").description("Test worktree prefix configuration - preview worktree paths (reads .iloom/settings.json)").action(async () => {
+  try {
+    const { TestPrefixCommand } = await import("./test-prefix-XGFXFAYN.js");
+    const command = new TestPrefixCommand();
+    await command.execute();
+  } catch (error) {
+    logger.error(`Test prefix failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("test-neon").description("Test Neon integration and debug configuration").action(async () => {
+  try {
+    const { NeonProvider } = await import("./NeonProvider-PAGPUH7F.js");
+    const { loadEnvIntoProcess } = await import("./env-MDFL4ZXL.js");
+    logger.info("Testing Neon Integration\n");
+    logger.info("0. Loading environment variables...");
+    const envResult = loadEnvIntoProcess();
+    if (envResult.error) {
+      logger.warn(`   Warning: ${envResult.error.message}`);
+    }
+    if (envResult.parsed) {
+      logger.success(`   Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+    } else {
+      logger.info("   No .env files found or parsed");
+    }
+    logger.info("\n1. Environment Variables:");
+    logger.info(`   NEON_PROJECT_ID: ${process.env.NEON_PROJECT_ID ?? "(not set)"}`);
+    logger.info(`   NEON_PARENT_BRANCH: ${process.env.NEON_PARENT_BRANCH ?? "(not set)"}`);
+    logger.info("\n2. Creating NeonProvider...");
+    try {
+      const neonProvider = new NeonProvider({
+        projectId: process.env.NEON_PROJECT_ID ?? "",
+        parentBranch: process.env.NEON_PARENT_BRANCH ?? ""
+      });
+      logger.success("   NeonProvider created successfully");
+      logger.info("\n3. Testing Neon CLI availability...");
+      const isAvailable = await neonProvider.isCliAvailable();
+      if (isAvailable) {
+        logger.success("   Neon CLI is available");
+      } else {
+        logger.error("   Neon CLI not found");
+        logger.info("   Install with: npm install -g @neon/cli");
+        return;
+      }
+      logger.info("\n4. Testing Neon CLI authentication...");
+      const isAuthenticated = await neonProvider.isAuthenticated();
+      if (isAuthenticated) {
+        logger.success("   Neon CLI is authenticated");
+      } else {
+        logger.error("   Neon CLI not authenticated");
+        logger.info("   Run: neon auth");
+        return;
+      }
+      if (process.env.NEON_PROJECT_ID) {
+        logger.info("\n5. Testing branch listing...");
+        try {
+          const branches = await neonProvider.listBranches();
+          logger.success(`   Found ${branches.length} branches:`);
+          for (const branch of branches.slice(0, 5)) {
+            logger.info(`     - ${branch}`);
+          }
+          if (branches.length > 5) {
+            logger.info(`     ... and ${branches.length - 5} more`);
+          }
+        } catch (error) {
+          logger.error(`   Failed to list branches: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      } else {
+        logger.warn("\n5. Skipping branch listing (NEON_PROJECT_ID not set)");
+      }
+    } catch (error) {
+      logger.error(`   Failed to create NeonProvider: ${error instanceof Error ? error.message : "Unknown error"}`);
+      if (error instanceof Error && error.message.includes("NEON_PROJECT_ID")) {
+        logger.info("\n   This is expected if NEON_PROJECT_ID is not set.");
+        logger.info("   Set NEON_PROJECT_ID and NEON_PARENT_BRANCH environment variables to test fully.");
+      }
+    }
+    logger.info("\n" + "=".repeat(50));
+    logger.success("Neon integration test complete!");
+  } catch (error) {
+    logger.error(`Test failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (error instanceof Error && error.stack) {
+      logger.debug(error.stack);
+    }
+    process.exit(1);
+  }
+});
+program.command("help").description("Display help information").argument("[command]", "Show help for specific command").action(async (command) => {
+  if (command) {
+    const subCommand = program.commands.find((cmd) => cmd.name() === command);
+    if (subCommand) {
+      subCommand.outputHelp();
+    } else {
+      logger.error(`Unknown command: ${command}`);
+      program.outputHelp();
+    }
+  } else {
+    program.outputHelp();
+  }
+  process.exit(0);
+});
+try {
+  await program.parseAsync();
+} catch (error) {
+  if (error instanceof Error) {
+    logger.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+//# sourceMappingURL=cli.js.map