@iloom/cli 0.2.0 → 0.3.1

package/dist/chunk-H5LDRGVK.js

@@ -1,642 +0,0 @@
-#!/usr/bin/env node
-import {
-  calculatePortForBranch,
-  formatEnvLine,
-  parseEnvFile,
-  validateEnvVariable
-} from "./chunk-ZMNQBJUI.js";
-import {
-  runScript
-} from "./chunk-BLCTGFZN.js";
-import {
-  hasScript,
-  readPackageJson
-} from "./chunk-2ZPFJQ3B.js";
-import {
-  createLogger,
-  logger
-} from "./chunk-GEHQXLEI.js";
-
-// src/lib/EnvironmentManager.ts
-import fs from "fs-extra";
-var logger2 = createLogger({ prefix: "\u{1F4DD}" });
-var EnvironmentManager = class {
-  constructor() {
-    this.backupSuffix = ".backup";
-  }
-  /**
-   * Set or update an environment variable in a .env file
-   * Ports functionality from bash/utils/env-utils.sh:setEnvVar()
-   * @returns The backup path if a backup was created
-   */
-  async setEnvVar(filePath, key, value, backup = false) {
-    const validation = validateEnvVariable(key, value);
-    if (!validation.valid) {
-      throw new Error(validation.error ?? "Invalid variable name");
-    }
-    const fileExists = await fs.pathExists(filePath);
-    if (!fileExists) {
-      logger2.info(`Creating ${filePath} with ${key}...`);
-      const content = formatEnvLine(key, value);
-      await fs.writeFile(filePath, content, "utf8");
-      logger2.success(`${filePath} created with ${key}`);
-      return;
-    }
-    const existingContent = await fs.readFile(filePath, "utf8");
-    const envMap = parseEnvFile(existingContent);
-    let backupPath;
-    if (backup) {
-      backupPath = await this.createBackup(filePath);
-    }
-    envMap.set(key, value);
-    const lines = existingContent.split("\n");
-    const newLines = [];
-    let variableUpdated = false;
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith("#")) {
-        newLines.push(line);
-        continue;
-      }
-      const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
-      const equalsIndex = cleanLine.indexOf("=");
-      if (equalsIndex !== -1) {
-        const lineKey = cleanLine.substring(0, equalsIndex).trim();
-        if (lineKey === key) {
-          newLines.push(formatEnvLine(key, value));
-          variableUpdated = true;
-          continue;
-        }
-      }
-      newLines.push(line);
-    }
-    if (!variableUpdated) {
-      logger2.info(`Adding ${key} to ${filePath}...`);
-      newLines.push(formatEnvLine(key, value));
-      logger2.success(`${key} added successfully`);
-    } else {
-      logger2.info(`Updating ${key} in ${filePath}...`);
-      logger2.success(`${key} updated successfully`);
-    }
-    const newContent = newLines.join("\n");
-    await fs.writeFile(filePath, newContent, "utf8");
-    return backupPath;
-  }
-  /**
-   * Read and parse a .env file
-   */
-  async readEnvFile(filePath) {
-    try {
-      const content = await fs.readFile(filePath, "utf8");
-      return parseEnvFile(content);
-    } catch (error) {
-      logger2.debug(
-        `Could not read env file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return /* @__PURE__ */ new Map();
-    }
-  }
-  /**
-   * Generic file copy helper that only copies if source exists
-   * Does not throw if source file doesn't exist - just logs and returns
-   * @private
-   */
-  async copyIfExists(source, destination) {
-    const sourceExists = await fs.pathExists(source);
-    if (!sourceExists) {
-      logger2.debug(`Source file ${source} does not exist, skipping copy`);
-      return;
-    }
-    await fs.copy(source, destination, { overwrite: false });
-    logger2.success(`Copied ${source} to ${destination}`);
-  }
-  /**
-   * Calculate unique port for workspace
-   * Implements:
-   * - Issue/PR: 3000 + issue/PR number
-   * - Branch: 3000 + deterministic hash offset (1-999)
-   */
-  calculatePort(options) {
-    const basePort = options.basePort ?? 3e3;
-    if (options.issueNumber !== void 0) {
-      const port = basePort + options.issueNumber;
-      if (port > 65535) {
-        throw new Error(
-          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
-        );
-      }
-      return port;
-    }
-    if (options.prNumber !== void 0) {
-      const port = basePort + options.prNumber;
-      if (port > 65535) {
-        throw new Error(
-          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or PR number.`
-        );
-      }
-      return port;
-    }
-    if (options.branchName !== void 0) {
-      return calculatePortForBranch(options.branchName, basePort);
-    }
-    return basePort;
-  }
-  /**
-   * Set port environment variable for workspace
-   */
-  async setPortForWorkspace(envFilePath, issueNumber, prNumber, branchName) {
-    const options = {};
-    if (issueNumber !== void 0) {
-      options.issueNumber = issueNumber;
-    }
-    if (prNumber !== void 0) {
-      options.prNumber = prNumber;
-    }
-    if (branchName !== void 0) {
-      options.branchName = branchName;
-    }
-    const port = this.calculatePort(options);
-    await this.setEnvVar(envFilePath, "PORT", String(port));
-    return port;
-  }
-  /**
-   * Validate environment configuration
-   */
-  async validateEnvFile(filePath) {
-    try {
-      const content = await fs.readFile(filePath, "utf8");
-      const envMap = parseEnvFile(content);
-      const errors = [];
-      for (const [key, value] of envMap.entries()) {
-        const validation = validateEnvVariable(key, value);
-        if (!validation.valid) {
-          errors.push(`${key}: ${validation.error}`);
-        }
-      }
-      return {
-        valid: errors.length === 0,
-        errors
-      };
-    } catch (error) {
-      return {
-        valid: false,
-        errors: [
-          `Failed to read or parse file: ${error instanceof Error ? error.message : String(error)}`
-        ]
-      };
-    }
-  }
-  /**
-   * Create backup of existing file
-   */
-  async createBackup(filePath) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = `${filePath}${this.backupSuffix}-${timestamp}`;
-    await fs.copy(filePath, backupPath);
-    logger2.debug(`Created backup at ${backupPath}`);
-    return backupPath;
-  }
-};
-
-// src/lib/CLIIsolationManager.ts
-import fs2 from "fs-extra";
-import path from "path";
-import os from "os";
-var CLIIsolationManager = class {
-  constructor() {
-    this.iloomBinDir = path.join(os.homedir(), ".iloom", "bin");
-  }
-  /**
-   * Setup CLI isolation for a worktree
-   * - Build the project
-   * - Create versioned symlinks
-   * - Check PATH configuration
-   * @param worktreePath Path to the worktree
-   * @param identifier Issue/PR number or branch identifier
-   * @param binEntries Bin entries from package.json
-   * @returns Array of created symlink names
-   */
-  async setupCLIIsolation(worktreePath, identifier, binEntries) {
-    await this.buildProject(worktreePath);
-    await this.verifyBinTargets(worktreePath, binEntries);
-    await fs2.ensureDir(this.iloomBinDir);
-    const symlinkNames = await this.createVersionedSymlinks(
-      worktreePath,
-      identifier,
-      binEntries
-    );
-    await this.ensureIloomBinInPath();
-    return symlinkNames;
-  }
-  /**
-   * Build the project using package.json build script
-   * @param worktreePath Path to the worktree
-   */
-  async buildProject(worktreePath) {
-    const pkgJson = await readPackageJson(worktreePath);
-    if (!hasScript(pkgJson, "build")) {
-      logger.warn("No build script found in package.json - skipping build");
-      return;
-    }
-    logger.info("Building CLI tool...");
-    await runScript("build", worktreePath);
-    logger.success("Build completed");
-  }
-  /**
-   * Verify bin targets exist and are executable
-   * @param worktreePath Path to the worktree
-   * @param binEntries Bin entries from package.json
-   */
-  async verifyBinTargets(worktreePath, binEntries) {
-    for (const binPath of Object.values(binEntries)) {
-      const targetPath = path.resolve(worktreePath, binPath);
-      const exists = await fs2.pathExists(targetPath);
-      if (!exists) {
-        throw new Error(`Bin target does not exist: ${targetPath}`);
-      }
-      try {
-        await fs2.access(targetPath, fs2.constants.X_OK);
-      } catch {
-      }
-    }
-  }
-  /**
-   * Create versioned symlinks in ~/.iloom/bin
-   * @param worktreePath Path to the worktree
-   * @param identifier Issue/PR number or branch identifier
-   * @param binEntries Bin entries from package.json
-   * @returns Array of created symlink names
-   */
-  async createVersionedSymlinks(worktreePath, identifier, binEntries) {
-    const symlinkNames = [];
-    for (const [binName, binPath] of Object.entries(binEntries)) {
-      const versionedName = `${binName}-${identifier}`;
-      const targetPath = path.resolve(worktreePath, binPath);
-      const symlinkPath = path.join(this.iloomBinDir, versionedName);
-      await fs2.symlink(targetPath, symlinkPath);
-      logger.success(`CLI available: ${versionedName}`);
-      symlinkNames.push(versionedName);
-    }
-    return symlinkNames;
-  }
-  /**
-   * Check if ~/.iloom/bin is in PATH and provide setup instructions
-   */
-  async ensureIloomBinInPath() {
-    const currentPath = process.env.PATH ?? "";
-    if (currentPath.includes(".iloom/bin")) {
-      return;
-    }
-    const shell = this.detectShell();
-    const rcFile = this.getShellRcFile(shell);
-    logger.warn("\n\u26A0\uFE0F  One-time PATH setup required:");
-    logger.warn(`   Add to ${rcFile}:`);
-    logger.warn(`   export PATH="$HOME/.iloom/bin:$PATH"`);
-    logger.warn(`   Then run: source ${rcFile}
-`);
-  }
-  /**
-   * Detect current shell
-   * @returns Shell name (zsh, bash, fish, etc.)
-   */
-  detectShell() {
-    const shell = process.env.SHELL ?? "";
-    return shell.split("/").pop() ?? "bash";
-  }
-  /**
-   * Get RC file path for shell
-   * @param shell Shell name
-   * @returns RC file path
-   */
-  getShellRcFile(shell) {
-    const rcFiles = {
-      zsh: "~/.zshrc",
-      bash: "~/.bashrc",
-      fish: "~/.config/fish/config.fish"
-    };
-    return rcFiles[shell] ?? "~/.bashrc";
-  }
-  /**
-   * Cleanup versioned CLI executables for a specific identifier
-   * Removes all symlinks matching the pattern: {binName}-{identifier}
-   *
-   * @param identifier - Issue/PR number or branch identifier
-   * @returns Array of removed symlink names
-   */
-  async cleanupVersionedExecutables(identifier) {
-    const removed = [];
-    try {
-      const files = await fs2.readdir(this.iloomBinDir);
-      for (const file of files) {
-        if (this.matchesIdentifier(file, identifier)) {
-          const symlinkPath = path.join(this.iloomBinDir, file);
-          try {
-            await fs2.unlink(symlinkPath);
-            removed.push(file);
-          } catch (error) {
-            const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-            if (isEnoent) {
-              removed.push(file);
-              continue;
-            }
-            logger.warn(
-              `Failed to remove symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-          }
-        }
-      }
-    } catch (error) {
-      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-      if (isEnoent) {
-        logger.warn("No CLI executables directory found - nothing to cleanup");
-        return [];
-      }
-      throw error;
-    }
-    if (removed.length > 0) {
-      logger.success(`Removed CLI executables: ${removed.join(", ")}`);
-    }
-    return removed;
-  }
-  /**
-   * Find orphaned symlinks in ~/.iloom/bin
-   * Returns symlinks that point to non-existent targets
-   *
-   * @returns Array of orphaned symlink information
-   */
-  async findOrphanedSymlinks() {
-    const orphaned = [];
-    try {
-      const files = await fs2.readdir(this.iloomBinDir);
-      for (const file of files) {
-        const symlinkPath = path.join(this.iloomBinDir, file);
-        try {
-          const stats = await fs2.lstat(symlinkPath);
-          if (stats.isSymbolicLink()) {
-            const target = await fs2.readlink(symlinkPath);
-            try {
-              await fs2.access(target);
-            } catch {
-              orphaned.push({
-                name: file,
-                path: symlinkPath,
-                brokenTarget: target
-              });
-            }
-          }
-        } catch (error) {
-          logger.warn(
-            `Failed to check symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    } catch (error) {
-      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-      if (isEnoent) {
-        return [];
-      }
-      throw error;
-    }
-    return orphaned;
-  }
-  /**
-   * Cleanup all orphaned symlinks
-   * Removes symlinks that point to non-existent targets
-   *
-   * @returns Number of symlinks removed
-   */
-  async cleanupOrphanedSymlinks() {
-    const orphaned = await this.findOrphanedSymlinks();
-    let removedCount = 0;
-    for (const symlink of orphaned) {
-      try {
-        await fs2.unlink(symlink.path);
-        removedCount++;
-        logger.success(`Removed orphaned symlink: ${symlink.name}`);
-      } catch (error) {
-        logger.warn(
-          `Failed to remove orphaned symlink ${symlink.name}: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    }
-    return removedCount;
-  }
-  /**
-   * Check if a filename matches the versioned pattern for an identifier
-   * Pattern: {binName}-{identifier}
-   *
-   * @param fileName - Name of the file to check
-   * @param identifier - Issue/PR number or branch identifier
-   * @returns True if the filename matches the pattern
-   */
-  matchesIdentifier(fileName, identifier) {
-    const suffix = `-${identifier}`;
-    return fileName.endsWith(suffix);
-  }
-};
-
-// src/lib/DatabaseManager.ts
-var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
-var DatabaseManager = class {
-  constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
-    this.provider = provider;
-    this.environment = environment;
-    this.databaseUrlEnvVarName = databaseUrlEnvVarName;
-    if (databaseUrlEnvVarName !== "DATABASE_URL") {
-      logger3.debug(`\u{1F527} DatabaseManager configured with custom variable: ${databaseUrlEnvVarName}`);
-    } else {
-      logger3.debug("\u{1F527} DatabaseManager using default variable: DATABASE_URL");
-    }
-  }
-  /**
-   * Get the configured database URL environment variable name
-   */
-  getConfiguredVariableName() {
-    return this.databaseUrlEnvVarName;
-  }
-  /**
-   * Check if database branching should be used
-   * Requires BOTH conditions:
-   *   1. Database provider is properly configured (checked via provider.isConfigured())
-   *   2. .env file contains the configured database URL variable
-   */
-  async shouldUseDatabaseBranching(envFilePath) {
-    if (!this.provider.isConfigured()) {
-      logger3.debug("Skipping database branching: Database provider not configured");
-      return false;
-    }
-    const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(envFilePath);
-    if (!hasDatabaseUrl) {
-      logger3.debug(
-        "Skipping database branching: configured database URL variable not found in .env file"
-      );
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Create database branch only if configured
-   * Returns connection string if branch was created, null if skipped
-   *
-   * @param branchName - Name of the branch to create
-   * @param envFilePath - Path to .env file for configuration checks
-   * @param cwd - Optional working directory to run commands from
-   */
-  async createBranchIfConfigured(branchName, envFilePath, cwd) {
-    if (!await this.shouldUseDatabaseBranching(envFilePath)) {
-      return null;
-    }
-    if (!await this.provider.isCliAvailable()) {
-      logger3.warn("Skipping database branch creation: Neon CLI not available");
-      logger3.warn("Install with: npm install -g neonctl");
-      return null;
-    }
-    try {
-      const isAuth = await this.provider.isAuthenticated(cwd);
-      if (!isAuth) {
-        logger3.warn("Skipping database branch creation: Not authenticated with Neon CLI");
-        logger3.warn("Run: neon auth");
-        return null;
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error(`Database authentication check failed: ${errorMessage}`);
-      throw error;
-    }
-    try {
-      const connectionString = await this.provider.createBranch(branchName, void 0, cwd);
-      logger3.success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
-      return connectionString;
-    } catch (error) {
-      logger3.error(
-        `Failed to create database branch: ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw error;
-    }
-  }
-  /**
-   * Delete database branch only if configured
-   * Returns result object indicating what happened
-   *
-   * @param branchName - Name of the branch to delete
-   * @param shouldCleanup - Boolean indicating if database cleanup should be performed (pre-fetched config)
-   * @param isPreview - Whether this is a preview database branch
-   * @param cwd - Optional working directory to run commands from (prevents issues with deleted directories)
-   */
-  async deleteBranchIfConfigured(branchName, shouldCleanup, isPreview = false, cwd) {
-    if (shouldCleanup === false) {
-      return {
-        success: true,
-        deleted: false,
-        notFound: true,
-        // Treat "not configured" as "nothing to delete"
-        branchName
-      };
-    }
-    if (!this.provider.isConfigured()) {
-      logger3.debug("Skipping database branch deletion: Database provider not configured");
-      return {
-        success: true,
-        deleted: false,
-        notFound: true,
-        branchName
-      };
-    }
-    if (!await this.provider.isCliAvailable()) {
-      logger3.info("Skipping database branch deletion: CLI tool not available");
-      return {
-        success: false,
-        deleted: false,
-        notFound: true,
-        error: "CLI tool not available",
-        branchName
-      };
-    }
-    try {
-      const isAuth = await this.provider.isAuthenticated(cwd);
-      if (!isAuth) {
-        logger3.warn("Skipping database branch deletion: Not authenticated with DB Provider");
-        return {
-          success: false,
-          deleted: false,
-          notFound: false,
-          error: "Not authenticated with DB Provider",
-          branchName
-        };
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger3.error(`Database authentication check failed: ${errorMessage}`);
-      return {
-        success: false,
-        deleted: false,
-        notFound: false,
-        error: `Authentication check failed: ${errorMessage}`,
-        branchName
-      };
-    }
-    try {
-      const result = await this.provider.deleteBranch(branchName, isPreview, cwd);
-      return result;
-    } catch (error) {
-      logger3.warn(
-        `Unexpected error in database deletion: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return {
-        success: false,
-        deleted: false,
-        notFound: false,
-        error: error instanceof Error ? error.message : String(error),
-        branchName
-      };
-    }
-  }
-  /**
-   * Check if .env has the configured database URL variable
-   * CRITICAL: If user explicitly configured a custom variable name (not default),
-   * throw an error if it's missing from .env
-   */
-  async hasDatabaseUrlInEnv(envFilePath) {
-    try {
-      const envMap = await this.environment.readEnvFile(envFilePath);
-      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-        logger3.debug(`Looking for custom database URL variable: ${this.databaseUrlEnvVarName}`);
-      } else {
-        logger3.debug("Looking for default database URL variable: DATABASE_URL");
-      }
-      if (envMap.has(this.databaseUrlEnvVarName)) {
-        if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-          logger3.debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
-        } else {
-          logger3.debug(`\u2705 Found default database URL variable: DATABASE_URL`);
-        }
-        return true;
-      }
-      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in .env file`);
-        throw new Error(
-          `Configured database URL environment variable '${this.databaseUrlEnvVarName}' not found in .env file. Please add it to your .env file or update your iloom configuration.`
-        );
-      }
-      const hasDefaultVar = envMap.has("DATABASE_URL");
-      if (hasDefaultVar) {
-        logger3.debug("\u2705 Found fallback DATABASE_URL variable");
-      } else {
-        logger3.debug("\u274C No DATABASE_URL variable found in .env file");
-      }
-      return hasDefaultVar;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("not found in .env")) {
-        throw error;
-      }
-      return false;
-    }
-  }
-};
-
-export {
-  EnvironmentManager,
-  CLIIsolationManager,
-  DatabaseManager
-};
-//# sourceMappingURL=chunk-H5LDRGVK.js.map