@iloom/cli 0.2.0 → 0.3.0

package/dist/finish-TX5CJICB.js

@@ -1,1749 +0,0 @@
-#!/usr/bin/env node
-import {
-  MergeManager
-} from "./chunk-4IV6W4U5.js";
-import {
-  ResourceCleanup
-} from "./chunk-SYOSCMIT.js";
-import {
-  IdentifierParser
-} from "./chunk-H4E4THUZ.js";
-import {
-  ProcessManager
-} from "./chunk-SPYPLHMK.js";
-import {
-  CLIIsolationManager,
-  DatabaseManager,
-  EnvironmentManager
-} from "./chunk-H5LDRGVK.js";
-import {
-  loadEnvIntoProcess
-} from "./chunk-ZMNQBJUI.js";
-import {
-  detectPackageManager,
-  installDependencies,
-  runScript
-} from "./chunk-BLCTGFZN.js";
-import {
-  createNeonProviderFromSettings
-} from "./chunk-LAPY6NAE.js";
-import {
-  ProjectCapabilityDetector
-} from "./chunk-CWR2SANQ.js";
-import {
-  hasScript,
-  readPackageJson
-} from "./chunk-2ZPFJQ3B.js";
-import {
-  openBrowser
-} from "./chunk-YETJNRQM.js";
-import {
-  getConfiguredRepoFromSettings,
-  getEffectivePRTargetRemote,
-  hasMultipleRemotes,
-  parseGitRemotes
-} from "./chunk-DJUGYNQE.js";
-import {
-  GitHubService
-} from "./chunk-TS6DL67T.js";
-import {
-  executeGhCommand
-} from "./chunk-SWCRXDZC.js";
-import {
-  detectClaudeCli,
-  launchClaude
-} from "./chunk-MFU53H6J.js";
-import {
-  GitWorktreeManager
-} from "./chunk-VETG35MF.js";
-import {
-  SettingsManager
-} from "./chunk-T3KEIB4D.js";
-import {
-  executeGitCommand,
-  findMainWorktreePathWithSettings,
-  pushBranchToRemote
-} from "./chunk-HBVFXN7R.js";
-import {
-  promptConfirmation
-} from "./chunk-JNKJ7NJV.js";
-import {
-  logger
-} from "./chunk-GEHQXLEI.js";
-
-// src/lib/ValidationRunner.ts
-var ValidationRunner = class {
-  /**
-   * Run all validations in sequence: typecheck → lint → test
-   * Fails fast on first error
-   */
-  async runValidations(worktreePath, options = {}) {
-    const startTime = Date.now();
-    const steps = [];
-    if (!options.skipTypecheck) {
-      const typecheckResult = await this.runTypecheck(
-        worktreePath,
-        options.dryRun ?? false
-      );
-      steps.push(typecheckResult);
-      if (!typecheckResult.passed && !typecheckResult.skipped) {
-        return {
-          success: false,
-          steps,
-          totalDuration: Date.now() - startTime
-        };
-      }
-    }
-    if (!options.skipLint) {
-      const lintResult = await this.runLint(worktreePath, options.dryRun ?? false);
-      steps.push(lintResult);
-      if (!lintResult.passed && !lintResult.skipped) {
-        return { success: false, steps, totalDuration: Date.now() - startTime };
-      }
-    }
-    if (!options.skipTests) {
-      const testResult = await this.runTests(
-        worktreePath,
-        options.dryRun ?? false
-      );
-      steps.push(testResult);
-      if (!testResult.passed && !testResult.skipped) {
-        return { success: false, steps, totalDuration: Date.now() - startTime };
-      }
-    }
-    return { success: true, steps, totalDuration: Date.now() - startTime };
-  }
-  /**
-   * Run typecheck validation
-   */
-  async runTypecheck(worktreePath, dryRun) {
-    const stepStartTime = Date.now();
-    try {
-      const pkgJson = await readPackageJson(worktreePath);
-      const hasTypecheckScript = hasScript(pkgJson, "typecheck");
-      if (!hasTypecheckScript) {
-        logger.debug("Skipping typecheck - no typecheck script found");
-        return {
-          step: "typecheck",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping typecheck - no package.json found (non-Node.js project)");
-        return {
-          step: "typecheck",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      throw error;
-    }
-    const packageManager = await detectPackageManager(worktreePath);
-    if (dryRun) {
-      const command = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
-      return {
-        step: "typecheck",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    }
-    logger.info("Running typecheck...");
-    try {
-      await runScript("typecheck", worktreePath, [], { quiet: true });
-      logger.success("Typecheck passed");
-      return {
-        step: "typecheck",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    } catch {
-      const fixed = await this.attemptClaudeFix(
-        "typecheck",
-        worktreePath,
-        packageManager
-      );
-      if (fixed) {
-        return {
-          step: "typecheck",
-          passed: true,
-          skipped: false,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      const runCommand = packageManager === "npm" ? "npm run typecheck" : `${packageManager} typecheck`;
-      throw new Error(
-        `Error: Typecheck failed.
-Fix type errors before merging.
-
-Run '${runCommand}' to see detailed errors.`
-      );
-    }
-  }
-  /**
-   * Run lint validation
-   */
-  async runLint(worktreePath, dryRun) {
-    const stepStartTime = Date.now();
-    try {
-      const pkgJson = await readPackageJson(worktreePath);
-      const hasLintScript = hasScript(pkgJson, "lint");
-      if (!hasLintScript) {
-        logger.debug("Skipping lint - no lint script found");
-        return {
-          step: "lint",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping lint - no package.json found (non-Node.js project)");
-        return {
-          step: "lint",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      throw error;
-    }
-    const packageManager = await detectPackageManager(worktreePath);
-    if (dryRun) {
-      const command = packageManager === "npm" ? "npm run lint" : `${packageManager} lint`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
-      return {
-        step: "lint",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    }
-    logger.info("Running lint...");
-    try {
-      await runScript("lint", worktreePath, [], { quiet: true });
-      logger.success("Linting passed");
-      return {
-        step: "lint",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    } catch {
-      const fixed = await this.attemptClaudeFix(
-        "lint",
-        worktreePath,
-        packageManager
-      );
-      if (fixed) {
-        return {
-          step: "lint",
-          passed: true,
-          skipped: false,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      const runCommand = packageManager === "npm" ? "npm run lint" : `${packageManager} lint`;
-      throw new Error(
-        `Error: Linting failed.
-Fix linting errors before merging.
-
-Run '${runCommand}' to see detailed errors.`
-      );
-    }
-  }
-  /**
-   * Run test validation
-   */
-  async runTests(worktreePath, dryRun) {
-    const stepStartTime = Date.now();
-    try {
-      const pkgJson = await readPackageJson(worktreePath);
-      const hasTestScript = hasScript(pkgJson, "test");
-      if (!hasTestScript) {
-        logger.debug("Skipping tests - no test script found");
-        return {
-          step: "test",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping tests - no package.json found (non-Node.js project)");
-        return {
-          step: "test",
-          passed: true,
-          skipped: true,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      throw error;
-    }
-    const packageManager = await detectPackageManager(worktreePath);
-    if (dryRun) {
-      const command = packageManager === "npm" ? "npm run test" : `${packageManager} test`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
-      return {
-        step: "test",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    }
-    logger.info("Running tests...");
-    try {
-      await runScript("test", worktreePath, [], { quiet: true });
-      logger.success("Tests passed");
-      return {
-        step: "test",
-        passed: true,
-        skipped: false,
-        duration: Date.now() - stepStartTime
-      };
-    } catch {
-      const fixed = await this.attemptClaudeFix(
-        "test",
-        worktreePath,
-        packageManager
-      );
-      if (fixed) {
-        return {
-          step: "test",
-          passed: true,
-          skipped: false,
-          duration: Date.now() - stepStartTime
-        };
-      }
-      const runCommand = packageManager === "npm" ? "npm run test" : `${packageManager} test`;
-      throw new Error(
-        `Error: Tests failed.
-Fix test failures before merging.
-
-Run '${runCommand}' to see detailed errors.`
-      );
-    }
-  }
-  /**
-   * Attempt to fix validation errors using Claude
-   * Pattern based on MergeManager.attemptClaudeConflictResolution
-   *
-   * @param validationType - Type of validation that failed ('typecheck' | 'lint' | 'test')
-   * @param worktreePath - Path to the worktree
-   * @param packageManager - Detected package manager
-   * @returns true if Claude fixed the issue, false otherwise
-   */
-  async attemptClaudeFix(validationType, worktreePath, packageManager) {
-    const isClaudeAvailable = await detectClaudeCli();
-    if (!isClaudeAvailable) {
-      logger.debug("Claude CLI not available, skipping auto-fix");
-      return false;
-    }
-    const validationCommand = this.getValidationCommand(validationType, packageManager);
-    const prompt = this.getClaudePrompt(validationType, validationCommand);
-    const validationTypeCapitalized = validationType.charAt(0).toUpperCase() + validationType.slice(1);
-    logger.info(`Launching Claude to help fix ${validationTypeCapitalized} errors...`);
-    try {
-      await launchClaude(prompt, {
-        addDir: worktreePath,
-        headless: false,
-        // Interactive mode
-        permissionMode: "acceptEdits",
-        // Auto-accept edits
-        model: "sonnet"
-        // Use Sonnet model
-      });
-      logger.info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`);
-      try {
-        await runScript(validationType, worktreePath, [], { quiet: true });
-        logger.success(`${validationTypeCapitalized} passed after Claude auto-fix`);
-        return true;
-      } catch {
-        logger.warn(`${validationTypeCapitalized} still failing after Claude's help`);
-        return false;
-      }
-    } catch (error) {
-      logger.warn("Claude auto-fix failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return false;
-    }
-  }
-  /**
-   * Get validation command string for prompts
-   */
-  getValidationCommand(validationType, packageManager) {
-    if (packageManager === "npm") {
-      return `npm run ${validationType}`;
-    }
-    return `${packageManager} ${validationType}`;
-  }
-  /**
-   * Get Claude prompt for specific validation type
-   * Matches bash script prompts exactly
-   */
-  getClaudePrompt(validationType, validationCommand) {
-    switch (validationType) {
-      case "typecheck":
-        return `There are TypeScript errors in this codebase. Please analyze the typecheck output, identify all type errors, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all type issues. When you are done, tell the user to quit using /exit to continue the validation process.`;
-      case "lint":
-        return `There are ESLint errors in this codebase. Please analyze the linting output, identify all linting issues, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all linting issues. Focus on code quality, consistency, and following the project's linting rules. When you are done, tell the user to quit using /exit to continue the validation process.`;
-      case "test":
-        return `There are unit test failures in this codebase. Please analyze the test output to understand what's failing, then fix the issues. This might involve updating test code, fixing bugs in the source code, or updating tests to match new behavior. Run '${validationCommand}' to see the detailed test failures, then make the necessary changes to get all tests passing. When you are done, tell the user to quit using /exit to continue the validation process.`;
-    }
-  }
-};
-
-// src/lib/CommitManager.ts
-var CommitManager = class {
-  /**
-   * Detect uncommitted changes in a worktree
-   * Parses git status --porcelain output into structured GitStatus
-   */
-  async detectUncommittedChanges(worktreePath) {
-    const porcelainOutput = await executeGitCommand(["status", "--porcelain"], {
-      cwd: worktreePath
-    });
-    const { stagedFiles, unstagedFiles } = this.parseGitStatus(porcelainOutput);
-    const currentBranch = await executeGitCommand(["branch", "--show-current"], {
-      cwd: worktreePath
-    });
-    return {
-      hasUncommittedChanges: stagedFiles.length > 0 || unstagedFiles.length > 0,
-      unstagedFiles,
-      stagedFiles,
-      currentBranch: currentBranch.trim(),
-      // Defer these to future enhancement
-      isAheadOfRemote: false,
-      isBehindRemote: false
-    };
-  }
-  /**
-   * Stage all changes and commit with Claude-generated or simple message
-   * Tries Claude first, falls back to simple message if Claude unavailable or fails
-   */
-  async commitChanges(worktreePath, options) {
-    if (options.dryRun) {
-      logger.info("[DRY RUN] Would run: git add -A");
-      logger.info("[DRY RUN] Would generate commit message with Claude (if available)");
-      const fallbackMessage = this.generateFallbackMessage(options);
-      const verifyFlag = options.skipVerify ? " --no-verify" : "";
-      logger.info(`[DRY RUN] Would commit with message${verifyFlag}: ${fallbackMessage}`);
-      return;
-    }
-    await executeGitCommand(["add", "-A"], { cwd: worktreePath });
-    let message = null;
-    if (!options.message) {
-      try {
-        message = await this.generateClaudeCommitMessage(worktreePath, options.issueNumber);
-      } catch (error) {
-        logger.debug("Claude commit message generation failed, using fallback", { error });
-      }
-    }
-    message ??= this.generateFallbackMessage(options);
-    if (options.skipVerify) {
-      logger.warn("\u26A0\uFE0F  Skipping pre-commit hooks (--no-verify configured in settings)");
-    }
-    try {
-      if (options.noReview || options.message) {
-        const commitArgs = ["commit", "-m", message];
-        if (options.skipVerify) {
-          commitArgs.push("--no-verify");
-        }
-        await executeGitCommand(commitArgs, { cwd: worktreePath });
-      } else {
-        logger.info("Opening git editor for commit message review...");
-        const commitArgs = ["commit", "-e", "-m", message];
-        if (options.skipVerify) {
-          commitArgs.push("--no-verify");
-        }
-        await executeGitCommand(commitArgs, {
-          cwd: worktreePath,
-          stdio: "inherit",
-          timeout: 3e5
-          // 5 minutes for interactive editing
-        });
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("nothing to commit")) {
-        logger.info("No changes to commit");
-        return;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Generate simple fallback commit message when Claude unavailable
-   * Used as fallback for Claude-powered commit messages
-   */
-  generateFallbackMessage(options) {
-    if (options.message) {
-      return options.message;
-    }
-    if (options.issueNumber) {
-      return `WIP: Auto-commit for issue #${options.issueNumber}
-
-Fixes #${options.issueNumber}`;
-    } else {
-      return "WIP: Auto-commit uncommitted changes";
-    }
-  }
-  /**
-   * Parse git status --porcelain output
-   * Format: "XY filename" where X=index, Y=worktree
-   * Examples:
-   *   "M  file.ts" - staged modification
-   *   " M file.ts" - unstaged modification
-   *   "MM file.ts" - both staged and unstaged
-   *   "?? file.ts" - untracked
-   */
-  parseGitStatus(porcelainOutput) {
-    const stagedFiles = [];
-    const unstagedFiles = [];
-    if (!porcelainOutput.trim()) {
-      return { stagedFiles, unstagedFiles };
-    }
-    const lines = porcelainOutput.split("\n").filter((line) => line.trim());
-    for (const line of lines) {
-      if (line.length < 3) continue;
-      const indexStatus = line[0];
-      const worktreeStatus = line[1];
-      const filename = line.substring(3);
-      if (indexStatus !== " " && indexStatus !== "?") {
-        stagedFiles.push(filename);
-      }
-      if (worktreeStatus !== " " || line.startsWith("??")) {
-        unstagedFiles.push(filename);
-      }
-    }
-    return { stagedFiles, unstagedFiles };
-  }
-  /**
-   * Generate commit message using Claude AI
-   * Claude examines the git repository directly via --add-dir option
-   * Returns null if Claude unavailable or fails validation
-   */
-  async generateClaudeCommitMessage(worktreePath, issueNumber) {
-    const startTime = Date.now();
-    logger.info("Starting Claude commit message generation...", {
-      worktreePath: worktreePath.split("/").pop(),
-      // Just show the folder name for privacy
-      issueNumber
-    });
-    logger.debug("Checking Claude CLI availability...");
-    const isClaudeAvailable = await detectClaudeCli();
-    if (!isClaudeAvailable) {
-      logger.info("Claude CLI not available, skipping Claude commit message generation");
-      return null;
-    }
-    logger.debug("Claude CLI is available");
-    logger.debug("Building commit message prompt...");
-    const prompt = this.buildCommitMessagePrompt(issueNumber);
-    logger.debug("Prompt built", { promptLength: prompt.length });
-    logger.debug("Claude prompt content:", {
-      prompt,
-      truncatedPreview: prompt.substring(0, 500) + (prompt.length > 500 ? "...[truncated]" : "")
-    });
-    try {
-      logger.info("Calling Claude CLI for commit message generation...");
-      const claudeStartTime = Date.now();
-      const claudeOptions = {
-        headless: true,
-        addDir: worktreePath,
-        model: "claude-haiku-4-5-20251001",
-        // Fast, cost-effective model
-        timeout: 12e4
-        // 120 second timeout
-      };
-      logger.debug("Claude CLI call parameters:", {
-        options: claudeOptions,
-        worktreePathForAnalysis: worktreePath,
-        addDirContents: "Will include entire worktree directory for analysis"
-      });
-      const result = await launchClaude(prompt, claudeOptions);
-      const claudeDuration = Date.now() - claudeStartTime;
-      logger.debug("Claude API call completed", { duration: `${claudeDuration}ms` });
-      if (typeof result !== "string") {
-        logger.warn("Claude returned non-string result", { resultType: typeof result });
-        return null;
-      }
-      logger.debug("Raw Claude output received", {
-        outputLength: result.length,
-        preview: result.substring(0, 200) + (result.length > 200 ? "..." : "")
-      });
-      logger.debug("Sanitizing Claude output...");
-      const sanitized = this.sanitizeClaudeOutput(result);
-      logger.debug("Output sanitized", {
-        originalLength: result.length,
-        sanitizedLength: sanitized.length,
-        sanitized: sanitized.substring(0, 200) + (sanitized.length > 200 ? "..." : "")
-      });
-      if (!sanitized) {
-        logger.warn("Claude returned empty message after sanitization");
-        return null;
-      }
-      let finalMessage = sanitized;
-      if (issueNumber) {
-        if (!finalMessage.includes(`Fixes #${issueNumber}`)) {
-          finalMessage = `${finalMessage}
-
-Fixes #${issueNumber}`;
-          logger.debug(`Added "Fixes #${issueNumber}" trailer to commit message`);
-        } else {
-          logger.debug(`"Fixes #${issueNumber}" already present in commit message`);
-        }
-      }
-      const totalDuration = Date.now() - startTime;
-      logger.info("Claude commit message generated successfully", {
-        message: finalMessage,
-        totalDuration: `${totalDuration}ms`,
-        claudeApiDuration: `${claudeDuration}ms`
-      });
-      return finalMessage;
-    } catch (error) {
-      const totalDuration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (errorMessage.includes("timed out") || errorMessage.includes("timeout")) {
-        logger.warn("Claude commit message generation timed out after 45 seconds", {
-          totalDuration: `${totalDuration}ms`,
-          worktreePath: worktreePath.split("/").pop()
-        });
-      } else {
-        logger.warn("Failed to generate commit message with Claude", {
-          error: errorMessage,
-          totalDuration: `${totalDuration}ms`,
-          worktreePath: worktreePath.split("/").pop()
-        });
-      }
-      return null;
-    }
-  }
-  /**
-   * Build structured XML prompt for commit message generation
-   * Uses XML format for clear task definition and output expectations
-   */
-  buildCommitMessagePrompt(issueNumber) {
-    const issueContext = issueNumber ? `
-<IssueContext>
-This commit is associated with GitHub issue #${issueNumber}.
-If the changes appear to resolve the issue, include "Fixes #${issueNumber}" at the end of the first line of commit message.
-</IssueContext>` : "";
-    return `<Task>
-You are a software engineer writing a commit message for this repository.
-Examine the staged changes in the git repository and generate a concise, meaningful commit message.
-</Task>
-
-<Requirements>
-<Format>The first line must be a brief summary of the changes made as a full sentence. If it references an issue, include "Fixes #N" at the end of this line.
-
-Add 2 newlines, then add a bullet-point form description of the changes made, each change on a new line.</Format>
-<Mood>Use imperative mood (e.g., "Add feature" not "Added feature")</Mood>
-<Focus>Be specific about what was changed and why</Focus>
-<Conciseness>Keep message under 72 characters for subject line when possible</Conciseness>
-<NoMeta>CRITICAL: Do NOT include ANY explanatory text, analysis, or meta-commentary. Output ONLY the raw commit message.</NoMeta>
-<Examples>
-Good: "Add user authentication with JWT tokens. Fixes #42
-
-- Implement login and registration endpoints
-- Secure routes with JWT middleware
-- Update user model to store hashed passwords"
-Good: "Fix navigation bug in sidebar menu."
-Bad: "Based on the changes, I'll create: Add user authentication"
-Bad: "Looking at the files, this commit should be: Fix navigation bug"
-</Examples>
-${issueContext}
-</Requirements>
-
-<Output>
-IMPORTANT: Your entire response will be used directly as the git commit message.
-Do not include any explanatory text before or after the commit message.
-Start your response immediately with the commit message text.
-</Output>`;
-  }
-  /**
-   * Sanitize Claude output to remove meta-commentary and clean formatting
-   * Handles cases where Claude includes explanatory text despite instructions
-   */
-  sanitizeClaudeOutput(rawOutput) {
-    let cleaned = rawOutput.trim();
-    const metaPatterns = [
-      /^.*?based on.*?changes.*?:/i,
-      /^.*?looking at.*?files.*?:/i,
-      /^.*?examining.*?:/i,
-      /^.*?analyzing.*?:/i,
-      /^.*?i'll.*?generate.*?:/i,
-      /^.*?let me.*?:/i,
-      /^.*?the commit message.*?should be.*?:/i,
-      /^.*?here.*?is.*?commit.*?message.*?:/i
-    ];
-    for (const pattern of metaPatterns) {
-      cleaned = cleaned.replace(pattern, "").trim();
-    }
-    if (cleaned.includes(":")) {
-      const colonIndex = cleaned.indexOf(":");
-      const beforeColon = cleaned.substring(0, colonIndex).trim().toLowerCase();
-      const metaIndicators = [
-        "here is the commit message",
-        "commit message",
-        "here is",
-        "the message should be",
-        "i suggest",
-        "my suggestion"
-      ];
-      const isMetaCommentary = metaIndicators.some((indicator) => beforeColon.includes(indicator));
-      if (isMetaCommentary) {
-        const afterColon = cleaned.substring(colonIndex + 1).trim();
-        if (afterColon && afterColon.length > 10) {
-          cleaned = afterColon;
-        }
-      }
-    }
-    if (cleaned.startsWith('"') && cleaned.endsWith('"') || cleaned.startsWith("'") && cleaned.endsWith("'")) {
-      cleaned = cleaned.slice(1, -1).trim();
-    }
-    return cleaned;
-  }
-};
-
-// src/lib/BuildRunner.ts
-var BuildRunner = class {
-  constructor(capabilityDetector) {
-    this.capabilityDetector = capabilityDetector ?? new ProjectCapabilityDetector();
-  }
-  /**
-   * Run build verification in the specified directory
-   * @param buildPath - Path where build should run (typically main worktree path)
-   * @param options - Build options
-   */
-  async runBuild(buildPath, options = {}) {
-    const startTime = Date.now();
-    try {
-      const pkgJson = await readPackageJson(buildPath);
-      const hasBuildScript = hasScript(pkgJson, "build");
-      if (!hasBuildScript) {
-        logger.debug("Skipping build - no build script found");
-        return {
-          success: true,
-          skipped: true,
-          reason: "No build script found in package.json",
-          duration: Date.now() - startTime
-        };
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("package.json not found")) {
-        logger.debug("Skipping build - no package.json found (non-Node.js project)");
-        return {
-          success: true,
-          skipped: true,
-          reason: "No package.json found in project",
-          duration: Date.now() - startTime
-        };
-      }
-      throw error;
-    }
-    const capabilities = await this.capabilityDetector.detectCapabilities(buildPath);
-    const isCLIProject = capabilities.capabilities.includes("cli");
-    if (!isCLIProject) {
-      logger.debug("Skipping build - not a CLI project (no bin field)");
-      return {
-        success: true,
-        skipped: true,
-        reason: "Project is not a CLI project (no bin field in package.json)",
-        duration: Date.now() - startTime
-      };
-    }
-    const packageManager = await detectPackageManager(buildPath);
-    if (options.dryRun) {
-      const command = packageManager === "npm" ? "npm run build" : `${packageManager} build`;
-      logger.info(`[DRY RUN] Would run: ${command}`);
-      return {
-        success: true,
-        skipped: false,
-        duration: Date.now() - startTime
-      };
-    }
-    logger.info("Running build...");
-    try {
-      await runScript("build", buildPath, [], { quiet: true });
-      logger.success("Build completed successfully");
-      return {
-        success: true,
-        skipped: false,
-        duration: Date.now() - startTime
-      };
-    } catch {
-      const runCommand = packageManager === "npm" ? "npm run build" : `${packageManager} build`;
-      throw new Error(
-        `Error: Build failed.
-Fix build errors before proceeding.
-
-Run '${runCommand}' to see detailed errors.`
-      );
-    }
-  }
-};
-
-// src/lib/PRManager.ts
-var PRManager = class {
-  constructor(settings) {
-    this.settings = settings;
-  }
-  /**
-   * Check if a PR already exists for the given branch
-   * @param branchName - Branch to check
-   * @param cwd - Working directory
-   * @returns Existing PR info or null if none found
-   */
-  async checkForExistingPR(branchName, cwd) {
-    try {
-      const prList = await executeGhCommand(
-        ["pr", "list", "--head", branchName, "--state", "open", "--json", "number,url"],
-        cwd ? { cwd } : void 0
-      );
-      if (prList.length > 0) {
-        return prList[0] ?? null;
-      }
-      return null;
-    } catch (error) {
-      logger.debug("Error checking for existing PR", { error });
-      return null;
-    }
-  }
-  /**
-   * Generate PR body using Claude if available, otherwise use simple template
-   * @param issueNumber - Issue number to include in body
-   * @param worktreePath - Path to worktree for context
-   * @returns PR body markdown
-   */
-  async generatePRBody(issueNumber, worktreePath) {
-    const hasClaudeCli = await detectClaudeCli();
-    if (hasClaudeCli) {
-      try {
-        const prompt = this.buildPRBodyPrompt(issueNumber);
-        const body2 = await launchClaude(prompt, {
-          headless: true,
-          addDir: worktreePath,
-          timeout: 3e4
-        });
-        if (body2 && typeof body2 === "string" && body2.trim()) {
-          const sanitized = this.sanitizeClaudeOutput(body2);
-          if (sanitized) {
-            return sanitized;
-          }
-        }
-      } catch (error) {
-        logger.debug("Claude PR body generation failed, using template", { error });
-      }
-    }
-    let body = "This PR contains changes from the iloom workflow.\n\n";
-    if (issueNumber) {
-      body += `Fixes #${issueNumber}`;
-    }
-    return body;
-  }
-  /**
-   * Build structured XML prompt for PR body generation
-   * Uses XML format for clear task definition and output expectations
-   */
-  buildPRBodyPrompt(issueNumber) {
-    const issueContext = issueNumber ? `
-<IssueContext>
-This PR is associated with GitHub issue #${issueNumber}.
-Include "Fixes #${issueNumber}" at the end of the body on its own line.
-</IssueContext>` : "";
-    return `<Task>
-You are a software engineer writing a pull request body for this repository.
-Examine the changes in the git repository and generate a concise, professional PR description.
-</Task>
-
-<Requirements>
-<Format>Write 2-3 sentences summarizing what was changed and why.${issueNumber ? `
-
-End with "Fixes #${issueNumber}" on its own line.` : ""}</Format>
-<Tone>Professional and concise</Tone>
-<Focus>Summarize the changes and their purpose</Focus>
-<NoMeta>CRITICAL: Do NOT include ANY explanatory text, analysis, or meta-commentary. Output ONLY the raw PR body text.</NoMeta>
-<Examples>
-Good: "Add user authentication with JWT tokens to secure the API endpoints. This includes login and registration endpoints with proper password hashing.
-
-Fixes #42"
-Good: "Fix navigation bug in sidebar menu that caused incorrect highlighting on nested routes."
-Bad: "Here's the PR body:
-
----
-
-Add user authentication..."
-Bad: "Based on the changes, I'll write: Fix navigation bug..."
-</Examples>
-${issueContext}
-</Requirements>
-
-<Output>
-IMPORTANT: Your entire response will be used directly as the GitHub pull request body.
-Do not include any explanatory text, headers, or separators before or after the body.
-Start your response immediately with the PR body text.
-</Output>`;
-  }
-  /**
-   * Sanitize Claude output to remove meta-commentary and clean formatting
-   * Handles cases where Claude includes explanatory text despite instructions
-   */
-  sanitizeClaudeOutput(rawOutput) {
-    let cleaned = rawOutput.trim();
-    const metaPatterns = [
-      /^.*?based on.*?changes.*?:/i,
-      /^.*?looking at.*?files.*?:/i,
-      /^.*?examining.*?:/i,
-      /^.*?analyzing.*?:/i,
-      /^.*?i'll.*?generate.*?:/i,
-      /^.*?let me.*?:/i,
-      /^.*?here.*?is.*?(?:the\s+)?(?:pr|pull request).*?body.*?:/i,
-      /^.*?here's.*?(?:the\s+)?(?:pr|pull request).*?body.*?:/i
-    ];
-    for (const pattern of metaPatterns) {
-      cleaned = cleaned.replace(pattern, "").trim();
-    }
-    cleaned = cleaned.replace(/^[-=]{3,}\s*/m, "").trim();
-    if (cleaned.includes(":")) {
-      const colonIndex = cleaned.indexOf(":");
-      const beforeColon = cleaned.substring(0, colonIndex).trim().toLowerCase();
-      const metaIndicators = [
-        "here is the pr body",
-        "here is the pull request body",
-        "pr body",
-        "pull request body",
-        "here is",
-        "here's",
-        "the body should be",
-        "i suggest",
-        "my suggestion"
-      ];
-      const isMetaCommentary = metaIndicators.some((indicator) => beforeColon.includes(indicator));
-      if (isMetaCommentary) {
-        const afterColon = cleaned.substring(colonIndex + 1).trim();
-        const afterSeparator = afterColon.replace(/^[-=]{3,}\s*/m, "").trim();
-        if (afterSeparator && afterSeparator.length > 10) {
-          cleaned = afterSeparator;
-        }
-      }
-    }
-    if (cleaned.startsWith('"') && cleaned.endsWith('"') || cleaned.startsWith("'") && cleaned.endsWith("'")) {
-      cleaned = cleaned.slice(1, -1).trim();
-    }
-    return cleaned;
-  }
-  /**
-   * Create a GitHub PR for the branch
-   * @param branchName - Branch to create PR from (used as --head)
-   * @param title - PR title
-   * @param body - PR body
-   * @param baseBranch - Base branch to target (usually main/master)
-   * @param cwd - Working directory
-   * @returns PR URL
-   */
-  async createPR(branchName, title, body, baseBranch, cwd) {
-    try {
-      const targetRemote = await getEffectivePRTargetRemote(this.settings, cwd);
-      let headValue = branchName;
-      if (targetRemote !== "origin") {
-        const remotes = await parseGitRemotes(cwd);
-        const originRemote = remotes.find((r) => r.name === "origin");
-        if (originRemote) {
-          headValue = `${originRemote.owner}:${branchName}`;
-          logger.debug(`Fork workflow detected, using head: ${headValue}`);
-        }
-      }
-      const args = ["pr", "create", "--head", headValue, "--title", title, "--body", body, "--base", baseBranch];
-      if (targetRemote !== "origin") {
-        const repo = await getConfiguredRepoFromSettings(this.settings, cwd);
-        args.push("--repo", repo);
-      }
-      const result = await executeGhCommand(args, cwd ? { cwd } : void 0);
-      const url = typeof result === "string" ? result.trim() : String(result).trim();
-      if (!url.includes("github.com") || !url.includes("/pull/")) {
-        throw new Error(`Unexpected response from gh pr create: ${url}`);
-      }
-      return url;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes("Head sha can't be blank") || errorMessage.includes("No commits between")) {
-        throw new Error(
-          `Failed to create pull request: ${errorMessage}
-
-This error typically occurs when:
-  - The branch was not fully pushed to the remote
-  - There's a race condition between push and PR creation
-  - The branch has no commits ahead of the base branch
-
-Try running: git push -u origin ${branchName}
-Then retry: il finish`
-        );
-      }
-      throw new Error(`Failed to create pull request: ${errorMessage}`);
-    }
-  }
-  /**
-   * Open PR URL in browser
-   * @param url - PR URL to open
-   */
-  async openPRInBrowser(url) {
-    try {
-      await openBrowser(url);
-      logger.debug("Opened PR in browser", { url });
-    } catch (error) {
-      logger.warn("Failed to open PR in browser", { error });
-    }
-  }
-  /**
-   * Complete PR workflow: check for existing, create if needed, optionally open in browser
-   * @param branchName - Branch to create PR from
-   * @param title - PR title
-   * @param issueNumber - Optional issue number for body generation
-   * @param baseBranch - Base branch to target
-   * @param worktreePath - Path to worktree
-   * @param openInBrowser - Whether to open PR in browser
-   * @returns PR creation result
-   */
-  async createOrOpenPR(branchName, title, issueNumber, baseBranch, worktreePath, openInBrowser) {
-    const existingPR = await this.checkForExistingPR(branchName, worktreePath);
-    if (existingPR) {
-      logger.info(`Pull request already exists: ${existingPR.url}`);
-      if (openInBrowser) {
-        await this.openPRInBrowser(existingPR.url);
-      }
-      return {
-        url: existingPR.url,
-        number: existingPR.number,
-        wasExisting: true
-      };
-    }
-    const body = await this.generatePRBody(issueNumber, worktreePath);
-    logger.info("Creating pull request...");
-    const url = await this.createPR(branchName, title, body, baseBranch, worktreePath);
-    const prNumber = this.extractPRNumberFromUrl(url);
-    if (openInBrowser) {
-      await this.openPRInBrowser(url);
-    }
-    return {
-      url,
-      number: prNumber,
-      wasExisting: false
-    };
-  }
-  /**
-   * Extract PR number from GitHub PR URL
-   * @param url - PR URL (e.g., https://github.com/owner/repo/pull/123)
-   * @returns PR number
-   */
-  extractPRNumberFromUrl(url) {
-    const match = url.match(/\/pull\/(\d+)/);
-    if (match == null ? void 0 : match[1]) {
-      return parseInt(match[1], 10);
-    }
-    throw new Error(`Could not extract PR number from URL: ${url}`);
-  }
-};
-
-// src/commands/finish.ts
-import path from "path";
-var FinishCommand = class {
-  constructor(gitHubService, gitWorktreeManager, validationRunner, commitManager, mergeManager, identifierParser, resourceCleanup, buildRunner, settingsManager) {
-    const envResult = loadEnvIntoProcess();
-    if (envResult.error) {
-      logger.debug(`Environment loading warning: ${envResult.error.message}`);
-    }
-    if (envResult.parsed) {
-      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
-    }
-    this.gitHubService = gitHubService ?? new GitHubService();
-    this.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager();
-    this.validationRunner = validationRunner ?? new ValidationRunner();
-    this.commitManager = commitManager ?? new CommitManager();
-    this.mergeManager = mergeManager ?? new MergeManager();
-    this.identifierParser = identifierParser ?? new IdentifierParser(this.gitWorktreeManager);
-    this.settingsManager = settingsManager ?? new SettingsManager();
-    if (resourceCleanup) {
-      this.resourceCleanup = resourceCleanup;
-    }
-    this.buildRunner = buildRunner ?? new BuildRunner();
-  }
-  /**
-   * Lazy initialization of ResourceCleanup with properly configured DatabaseManager
-   */
-  async ensureResourceCleanup() {
-    var _a, _b;
-    if (this.resourceCleanup) {
-      return;
-    }
-    const settings = await this.settingsManager.loadSettings();
-    const databaseUrlEnvVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
-    const environmentManager = new EnvironmentManager();
-    const neonProvider = createNeonProviderFromSettings(settings);
-    const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
-    const cliIsolationManager = new CLIIsolationManager();
-    this.resourceCleanup = new ResourceCleanup(
-      this.gitWorktreeManager,
-      new ProcessManager(),
-      databaseManager,
-      cliIsolationManager
-    );
-  }
-  /**
-   * Main entry point for finish command
-   */
-  async execute(input) {
-    try {
-      const settings = await this.settingsManager.loadSettings();
-      let repo;
-      const multipleRemotes = await hasMultipleRemotes();
-      if (multipleRemotes) {
-        repo = await getConfiguredRepoFromSettings(settings);
-        logger.info(`Using GitHub repository: ${repo}`);
-      }
-      const parsed = await this.parseInput(input.identifier, input.options);
-      const worktrees = await this.validateInput(parsed, input.options, repo);
-      logger.info(`Validated input: ${this.formatParsedInput(parsed)}`);
-      const worktree = worktrees[0];
-      if (!worktree) {
-        throw new Error("No worktree found");
-      }
-      if (parsed.type === "pr") {
-        if (!parsed.number) {
-          throw new Error("Invalid PR number");
-        }
-        const pr = await this.gitHubService.fetchPR(parsed.number, repo);
-        await this.executePRWorkflow(parsed, input.options, worktree, pr);
-      } else {
-        await this.executeIssueWorkflow(parsed, input.options, worktree);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        logger.error(`${error.message}`);
-      } else {
-        logger.error("An unknown error occurred");
-      }
-      throw error;
-    }
-  }
-  /**
-   * Parse input to determine type and extract relevant data
-   * Supports auto-detection from current directory when identifier is undefined
-   */
-  async parseInput(identifier, options) {
-    if (options.pr !== void 0) {
-      return {
-        type: "pr",
-        number: options.pr,
-        originalInput: `--pr ${options.pr}`,
-        autoDetected: false
-      };
-    }
-    if (identifier == null ? void 0 : identifier.trim()) {
-      return await this.parseExplicitInput(identifier.trim());
-    }
-    return await this.autoDetectFromCurrentDirectory();
-  }
-  /**
-   * Parse explicit identifier input using pattern-based detection
-   * (No GitHub API calls - uses IdentifierParser)
-   */
-  async parseExplicitInput(identifier) {
-    const prPattern = /^(?:pr|PR)[/-](\d+)$/;
-    const prMatch = identifier.match(prPattern);
-    if (prMatch == null ? void 0 : prMatch[1]) {
-      return {
-        type: "pr",
-        number: parseInt(prMatch[1], 10),
-        originalInput: identifier,
-        autoDetected: false
-      };
-    }
-    const parsed = await this.identifierParser.parseForPatternDetection(identifier);
-    if (parsed.type === "description") {
-      throw new Error("Description input type is not supported in finish command");
-    }
-    const result = {
-      type: parsed.type,
-      originalInput: parsed.originalInput,
-      autoDetected: false
-    };
-    if (parsed.number !== void 0) {
-      result.number = parsed.number;
-    }
-    if (parsed.branchName !== void 0) {
-      result.branchName = parsed.branchName;
-    }
-    return result;
-  }
-  /**
-   * Auto-detect PR or issue from current directory
-   * Ports logic from merge-current-issue.sh lines 30-52
-   */
-  async autoDetectFromCurrentDirectory() {
-    const currentDir = path.basename(process.cwd());
-    const prPattern = /_pr_(\d+)$/;
-    const prMatch = currentDir.match(prPattern);
-    if (prMatch == null ? void 0 : prMatch[1]) {
-      const prNumber = parseInt(prMatch[1], 10);
-      logger.debug(`Auto-detected PR #${prNumber} from directory: ${currentDir}`);
-      return {
-        type: "pr",
-        number: prNumber,
-        originalInput: currentDir,
-        autoDetected: true
-      };
-    }
-    const issuePattern = /issue-(\d+)/;
-    const issueMatch = currentDir.match(issuePattern);
-    if (issueMatch == null ? void 0 : issueMatch[1]) {
-      const issueNumber = parseInt(issueMatch[1], 10);
-      logger.debug(
-        `Auto-detected issue #${issueNumber} from directory: ${currentDir}`
-      );
-      return {
-        type: "issue",
-        number: issueNumber,
-        originalInput: currentDir,
-        autoDetected: true
-      };
-    }
-    const repoInfo = await this.gitWorktreeManager.getRepoInfo();
-    const currentBranch = repoInfo.currentBranch;
-    if (!currentBranch) {
-      throw new Error(
-        "Could not auto-detect identifier. Please provide an issue number, PR number, or branch name.\nExpected directory pattern: feat/issue-XX-description OR worktree with _pr_N suffix"
-      );
-    }
-    const branchIssueMatch = currentBranch.match(issuePattern);
-    if (branchIssueMatch == null ? void 0 : branchIssueMatch[1]) {
-      const issueNumber = parseInt(branchIssueMatch[1], 10);
-      logger.debug(
-        `Auto-detected issue #${issueNumber} from branch: ${currentBranch}`
-      );
-      return {
-        type: "issue",
-        number: issueNumber,
-        originalInput: currentBranch,
-        autoDetected: true
-      };
-    }
-    return {
-      type: "branch",
-      branchName: currentBranch,
-      originalInput: currentBranch,
-      autoDetected: true
-    };
-  }
-  /**
-   * Validate the parsed input based on its type
-   */
-  async validateInput(parsed, options, repo) {
-    switch (parsed.type) {
-      case "pr": {
-        if (!parsed.number) {
-          throw new Error("Invalid PR number");
-        }
-        const pr = await this.gitHubService.fetchPR(parsed.number);
-        logger.debug(`Validated PR #${parsed.number} (state: ${pr.state})`);
-        return await this.findWorktreeForIdentifier(parsed);
-      }
-      case "issue": {
-        if (!parsed.number) {
-          throw new Error("Invalid issue number");
-        }
-        const issue = await this.gitHubService.fetchIssue(parsed.number, repo);
-        if (issue.state === "closed" && !options.force) {
-          throw new Error(
-            `Issue #${parsed.number} is closed. Use --force to finish anyway.`
-          );
-        }
-        logger.debug(`Validated issue #${parsed.number} (state: ${issue.state})`);
-        return await this.findWorktreeForIdentifier(parsed);
-      }
-      case "branch": {
-        if (!parsed.branchName) {
-          throw new Error("Invalid branch name");
-        }
-        if (!this.isValidBranchName(parsed.branchName)) {
-          throw new Error(
-            "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
-          );
-        }
-        logger.debug(`Validated branch name: ${parsed.branchName}`);
-        return await this.findWorktreeForIdentifier(parsed);
-      }
-      default: {
-        const unknownType = parsed;
-        throw new Error(`Unknown input type: ${unknownType.type}`);
-      }
-    }
-  }
-  /**
-   * Find worktree for the given identifier using specific methods based on type
-   * (uses precise pattern matching instead of broad substring matching)
-   * Throws error if not found
-   */
-  async findWorktreeForIdentifier(parsed) {
-    let worktree = null;
-    switch (parsed.type) {
-      case "pr": {
-        if (!parsed.number) {
-          throw new Error("Invalid PR number");
-        }
-        worktree = await this.gitWorktreeManager.findWorktreeForPR(
-          parsed.number,
-          ""
-        );
-        break;
-      }
-      case "issue": {
-        if (!parsed.number) {
-          throw new Error("Invalid issue number");
-        }
-        worktree = await this.gitWorktreeManager.findWorktreeForIssue(
-          parsed.number
-        );
-        break;
-      }
-      case "branch": {
-        if (!parsed.branchName) {
-          throw new Error("Invalid branch name");
-        }
-        worktree = await this.gitWorktreeManager.findWorktreeForBranch(
-          parsed.branchName
-        );
-        break;
-      }
-      default: {
-        const unknownType = parsed;
-        throw new Error(`Unknown input type: ${unknownType.type}`);
-      }
-    }
-    if (!worktree) {
-      throw new Error(
-        `No worktree found for ${this.formatParsedInput(parsed)}. Use 'il list' to see available worktrees.`
-      );
-    }
-    logger.debug(`Found worktree: ${worktree.path}`);
-    return [worktree];
-  }
-  /**
-   * Validate branch name format
-   */
-  isValidBranchName(branch) {
-    return /^[a-zA-Z0-9/_-]+$/.test(branch);
-  }
-  /**
-   * Format parsed input for display
-   */
-  formatParsedInput(parsed) {
-    const autoLabel = parsed.autoDetected ? " (auto-detected)" : "";
-    switch (parsed.type) {
-      case "pr":
-        return `PR #${parsed.number}${autoLabel}`;
-      case "issue":
-        return `Issue #${parsed.number}${autoLabel}`;
-      case "branch":
-        return `Branch '${parsed.branchName}'${autoLabel}`;
-      default:
-        return "Unknown input";
-    }
-  }
-  /**
-   * Execute workflow for issues and branches (merge into main)
-   * This is the traditional workflow: validate → commit → rebase → merge → cleanup
-   */
-  async executeIssueWorkflow(parsed, options, worktree) {
-    var _a, _b;
-    if (!options.dryRun) {
-      logger.info("Running pre-merge validations...");
-      await this.validationRunner.runValidations(worktree.path, {
-        dryRun: options.dryRun ?? false
-      });
-      logger.success("All validations passed");
-    } else {
-      logger.info("[DRY RUN] Would run pre-merge validations");
-    }
-    const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
-    if (gitStatus.hasUncommittedChanges) {
-      if (options.dryRun) {
-        logger.info("[DRY RUN] Would auto-commit uncommitted changes (validation passed)");
-      } else {
-        logger.info("Validation passed, auto-committing uncommitted changes...");
-        const settings2 = await this.settingsManager.loadSettings(worktree.path);
-        const skipVerify = ((_b = (_a = settings2.workflows) == null ? void 0 : _a.issue) == null ? void 0 : _b.noVerify) ?? false;
-        const commitOptions = {
-          dryRun: options.dryRun ?? false,
-          skipVerify
-        };
-        if (parsed.type === "issue" && parsed.number) {
-          commitOptions.issueNumber = parsed.number;
-        }
-        await this.commitManager.commitChanges(worktree.path, commitOptions);
-        logger.success("Changes committed successfully");
-      }
-    } else {
-      logger.debug("No uncommitted changes found");
-    }
-    const settings = await this.settingsManager.loadSettings(worktree.path);
-    const mergeBehavior = settings.mergeBehavior ?? { mode: "local" };
-    if (mergeBehavior.mode === "github-pr") {
-      await this.executeGitHubPRWorkflow(parsed, options, worktree, settings);
-      return;
-    }
-    logger.info("Rebasing branch on main...");
-    const mergeOptions = {
-      dryRun: options.dryRun ?? false,
-      force: options.force ?? false
-    };
-    await this.mergeManager.rebaseOnMain(worktree.path, mergeOptions);
-    logger.success("Branch rebased successfully");
-    logger.info("Performing fast-forward merge...");
-    await this.mergeManager.performFastForwardMerge(worktree.branch, worktree.path, mergeOptions);
-    logger.success("Fast-forward merge completed successfully");
-    if (options.dryRun) {
-      logger.info("[DRY RUN] Would install dependencies in main worktree");
-    } else {
-      logger.info("Installing dependencies in main worktree...");
-      const mainWorktreePath = await findMainWorktreePathWithSettings(worktree.path, this.settingsManager);
-      await installDependencies(mainWorktreePath, true);
-    }
-    if (!options.skipBuild) {
-      await this.runPostMergeBuild(worktree.path, options);
-    } else {
-      logger.debug("Skipping build verification (--skip-build flag provided)");
-    }
-    await this.performPostMergeCleanup(parsed, options, worktree);
-  }
-  /**
-   * Execute workflow for Pull Requests
-   * Behavior depends on PR state:
-   * - OPEN: Commit changes, push to remote, keep worktree active
-   * - CLOSED/MERGED: Skip to cleanup
-   */
-  async executePRWorkflow(parsed, options, worktree, pr) {
-    var _a, _b;
-    if (pr.state === "closed" || pr.state === "merged") {
-      logger.info(`PR #${parsed.number} is ${pr.state.toUpperCase()} - skipping to cleanup`);
-      const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
-      if (gitStatus.hasUncommittedChanges && !options.force) {
-        logger.warn("PR has uncommitted changes");
-        throw new Error(
-          "Cannot cleanup PR with uncommitted changes. Commit or stash changes, then run again with --force to cleanup anyway."
-        );
-      }
-      await this.performPRCleanup(parsed, options, worktree);
-      logger.success(`PR #${parsed.number} cleanup completed`);
-    } else {
-      logger.info(`PR #${parsed.number} is OPEN - will push changes and keep worktree active`);
-      const gitStatus = await this.commitManager.detectUncommittedChanges(worktree.path);
-      if (gitStatus.hasUncommittedChanges) {
-        if (options.dryRun) {
-          logger.info("[DRY RUN] Would commit uncommitted changes");
-        } else {
-          logger.info("Committing uncommitted changes...");
-          const settings = await this.settingsManager.loadSettings(worktree.path);
-          const skipVerify = ((_b = (_a = settings.workflows) == null ? void 0 : _a.pr) == null ? void 0 : _b.noVerify) ?? false;
-          await this.commitManager.commitChanges(worktree.path, {
-            dryRun: false,
-            skipVerify
-            // Do NOT pass issueNumber for PRs - no "Fixes #" trailer needed
-          });
-          logger.success("Changes committed");
-        }
-      } else {
-        logger.debug("No uncommitted changes found");
-      }
-      if (options.dryRun) {
-        logger.info(`[DRY RUN] Would push changes to origin/${pr.branch}`);
-      } else {
-        logger.info("Pushing changes to remote...");
-        const { pushBranchToRemote: pushBranchToRemote2 } = await import("./git-WC6HZLOT.js");
-        await pushBranchToRemote2(pr.branch, worktree.path, {
-          dryRun: false
-        });
-        logger.success(`Changes pushed to PR #${parsed.number}`);
-      }
-      logger.success(`PR #${parsed.number} updated successfully`);
-      logger.info("Worktree remains active for continued work");
-      logger.info(`To cleanup when done: il cleanup ${parsed.number}`);
-    }
-  }
-  /**
-   * Execute workflow for GitHub PR creation (github-pr merge mode)
-   * Validates → Commits → Pushes → Creates PR → Prompts for cleanup
-   */
-  async executeGitHubPRWorkflow(parsed, options, worktree, settings) {
-    if (options.dryRun) {
-      logger.info("[DRY RUN] Would push branch to origin");
-    } else {
-      logger.info("Pushing branch to origin...");
-      await pushBranchToRemote(worktree.branch, worktree.path, { dryRun: false });
-      logger.success("Branch pushed successfully");
-    }
-    const prManager = new PRManager(settings);
-    let prTitle = `Work from ${worktree.branch}`;
-    if (parsed.type === "issue" && parsed.number) {
-      try {
-        const issue = await this.gitHubService.fetchIssue(parsed.number);
-        prTitle = issue.title;
-      } catch (error) {
-        logger.debug("Could not fetch issue title, using branch name", { error });
-      }
-    }
-    if (options.dryRun) {
-      logger.info("[DRY RUN] Would create GitHub PR");
-      logger.info(`  Title: ${prTitle}`);
-      logger.info(`  Base: ${settings.mainBranch ?? "main"}`);
-    } else {
-      const baseBranch = settings.mainBranch ?? "main";
-      const openInBrowser = options.noBrowser !== true;
-      const result = await prManager.createOrOpenPR(
-        worktree.branch,
-        prTitle,
-        parsed.type === "issue" ? parsed.number : void 0,
-        baseBranch,
-        worktree.path,
-        openInBrowser
-      );
-      if (result.wasExisting) {
-        logger.success(`Existing pull request: ${result.url}`);
-      } else {
-        logger.success(`Pull request created: ${result.url}`);
-      }
-      await this.handlePRCleanupPrompt(parsed, options, worktree);
-    }
-  }
-  /**
-   * Handle cleanup prompt after PR creation
-   * Respects --cleanup and --no-cleanup flags, otherwise prompts user
-   */
-  async handlePRCleanupPrompt(parsed, options, worktree) {
-    if (options.cleanup === true) {
-      logger.info("Cleaning up worktree (--cleanup flag)...");
-      await this.performWorktreeCleanup(parsed, options, worktree);
-    } else if (options.cleanup === false) {
-      logger.info("Worktree kept active for continued work (--no-cleanup flag)");
-      logger.info(`To cleanup later: il cleanup ${parsed.originalInput}`);
-    } else {
-      logger.info("");
-      logger.info("PR created successfully. Would you like to clean up the worktree?");
-      logger.info(`  Worktree: ${worktree.path}`);
-      logger.info(`  Branch: ${worktree.branch}`);
-      logger.info("");
-      const shouldCleanup = await promptConfirmation(
-        "Clean up worktree now?",
-        false
-        // Default to keeping worktree (safer option)
-      );
-      if (shouldCleanup) {
-        await this.performWorktreeCleanup(parsed, options, worktree);
-      } else {
-        logger.info("Worktree kept active. Run `il cleanup` when ready.");
-      }
-    }
-  }
-  /**
-   * Perform worktree cleanup (used by GitHub PR workflow)
-   * Similar to performPostMergeCleanup but for PR workflow
-   */
-  async performWorktreeCleanup(parsed, options, worktree) {
-    const cleanupInput = {
-      type: parsed.type,
-      originalInput: parsed.originalInput,
-      ...parsed.number !== void 0 && { number: parsed.number },
-      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
-    };
-    const cleanupOptions = {
-      dryRun: options.dryRun ?? false,
-      deleteBranch: false,
-      // Don't delete branch - PR still needs it
-      keepDatabase: false,
-      // Clean up database
-      force: options.force ?? false
-    };
-    try {
-      logger.info("Starting worktree cleanup...");
-      await this.ensureResourceCleanup();
-      if (!this.resourceCleanup) {
-        throw new Error("Failed to initialize ResourceCleanup");
-      }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
-        this.showManualCleanupInstructions(worktree);
-      } else {
-        logger.success("Worktree cleanup completed successfully");
-      }
-      if (this.isRunningFromWithinWorktree(worktree.path)) {
-        this.showTerminalCloseWarning(worktree);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
-      logger.warn("Manual cleanup may be required");
-      this.showManualCleanupInstructions(worktree);
-    }
-  }
-  /**
-   * Perform cleanup for closed/merged PRs
-   * Similar to performPostMergeCleanup but with different messaging
-   */
-  async performPRCleanup(parsed, options, worktree) {
-    const cleanupInput = {
-      type: parsed.type,
-      originalInput: parsed.originalInput,
-      ...parsed.number !== void 0 && { number: parsed.number },
-      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
-    };
-    const cleanupOptions = {
-      dryRun: options.dryRun ?? false,
-      deleteBranch: true,
-      // Delete branch for closed/merged PRs
-      keepDatabase: false,
-      force: options.force ?? false
-    };
-    try {
-      await this.ensureResourceCleanup();
-      if (!this.resourceCleanup) {
-        throw new Error("Failed to initialize ResourceCleanup");
-      }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
-        this.showManualCleanupInstructions(worktree);
-      } else {
-        if (this.isRunningFromWithinWorktree(worktree.path)) {
-          this.showTerminalCloseWarning(worktree);
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
-      this.showManualCleanupInstructions(worktree);
-      throw error;
-    }
-  }
-  /**
-   * Run post-merge build verification for CLI projects
-   * Runs in main worktree to verify merged code builds successfully
-   */
-  async runPostMergeBuild(worktreePath, options) {
-    const mainWorktreePath = await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
-    if (options.dryRun) {
-      logger.info("[DRY RUN] Would run post-merge build");
-      return;
-    }
-    logger.info("Running post-merge build...");
-    const result = await this.buildRunner.runBuild(mainWorktreePath, {
-      dryRun: options.dryRun ?? false
-    });
-    if (result.skipped) {
-      logger.debug(`Build skipped: ${result.reason}`);
-    } else {
-      logger.success("Post-merge build completed successfully");
-    }
-  }
-  /**
-   * Perform post-merge cleanup operations
-   * Converts ParsedFinishInput to ParsedInput and calls ResourceCleanup
-   * Handles failures gracefully without throwing
-   */
-  async performPostMergeCleanup(parsed, options, worktree) {
-    const cleanupInput = {
-      type: parsed.type,
-      originalInput: parsed.originalInput,
-      ...parsed.number !== void 0 && { number: parsed.number },
-      ...parsed.branchName !== void 0 && { branchName: parsed.branchName }
-    };
-    const cleanupOptions = {
-      dryRun: options.dryRun ?? false,
-      deleteBranch: true,
-      // Delete branch after successful merge
-      keepDatabase: false,
-      // Clean up database after merge
-      force: options.force ?? false
-    };
-    try {
-      logger.info("Starting post-merge cleanup...");
-      await this.ensureResourceCleanup();
-      if (!this.resourceCleanup) {
-        throw new Error("Failed to initialize ResourceCleanup");
-      }
-      const result = await this.resourceCleanup.cleanupWorktree(cleanupInput, cleanupOptions);
-      this.reportCleanupResults(result);
-      if (!result.success) {
-        logger.warn("Some cleanup operations failed - manual cleanup may be required");
-        this.showManualCleanupInstructions(worktree);
-      } else {
-        logger.success("Post-merge cleanup completed successfully");
-      }
-      if (this.isRunningFromWithinWorktree(worktree.path)) {
-        this.showTerminalCloseWarning(worktree);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.warn(`Cleanup failed: ${errorMessage}`);
-      logger.warn("Merge completed successfully, but manual cleanup is required");
-      this.showManualCleanupInstructions(worktree);
-    }
-  }
-  /**
-   * Report cleanup operation results to user
-   */
-  reportCleanupResults(result) {
-    if (result.operations.length === 0) {
-      return;
-    }
-    logger.info("Cleanup operations:");
-    for (const op of result.operations) {
-      const status = op.success ? "\u2713" : "\u2717";
-      const message = op.error ? `${op.message}: ${op.error}` : op.message;
-      if (op.success) {
-        logger.info(`  ${status} ${message}`);
-      } else {
-        logger.warn(`  ${status} ${message}`);
-      }
-    }
-  }
-  /**
-   * Show manual cleanup instructions when cleanup fails
-   */
-  showManualCleanupInstructions(worktree) {
-    logger.info("\nManual cleanup commands:");
-    logger.info(`  1. Remove worktree: git worktree remove ${worktree.path}`);
-    logger.info(`  2. Delete branch: git branch -d ${worktree.branch}`);
-    logger.info(`  3. Check dev servers: lsof -i :PORT (and kill if needed)`);
-  }
-  /**
-   * Check if current working directory is within the target worktree
-   */
-  isRunningFromWithinWorktree(worktreePath) {
-    const normalizedCwd = path.normalize(process.cwd());
-    const normalizedWorktree = path.normalize(worktreePath);
-    return normalizedCwd.startsWith(normalizedWorktree);
-  }
-  /**
-   * Display warning to close terminal/IDE when running from within finished loom
-   */
-  showTerminalCloseWarning(worktree) {
-    logger.info("");
-    logger.info("You are currently in the directory of the loom that was just finished.");
-    logger.info("Please close this terminal and any IDE/terminal windows using this directory.");
-    logger.info(`Directory: ${worktree.path}`);
-  }
-};
-export {
-  FinishCommand
-};
-//# sourceMappingURL=finish-TX5CJICB.js.map