@iloom/cli 0.1.14

package/dist/finish-CY4CIH6O.js

@@ -0,0 +1,1608 @@
+#!/usr/bin/env node
+import {
+  ResourceCleanup
+} from "./chunk-CP2NU2JC.js";
+import {
+  IdentifierParser
+} from "./chunk-H4E4THUZ.js";
+import {
+  ProcessManager
+} from "./chunk-SPYPLHMK.js";
+import {
+  CLIIsolationManager,
+  DatabaseManager,
+  EnvironmentManager
+} from "./chunk-HPJJSYNS.js";
+import "./chunk-37DYYFVK.js";
+import {
+  detectPackageManager,
+  installDependencies,
+  runScript
+} from "./chunk-BLCTGFZN.js";
+import {
+  NeonProvider
+} from "./chunk-YYSKGAZT.js";
+import {
+  ProjectCapabilityDetector
+} from "./chunk-CWR2SANQ.js";
+import {
+  hasScript,
+  readPackageJson
+} from "./chunk-2ZPFJQ3B.js";
+import {
+  GitHubService
+} from "./chunk-T7QPXANZ.js";
+import "./chunk-KQDEK2ZW.js";
+import {
+  loadEnvIntoProcess
+} from "./chunk-SJUQ2NDR.js";
+import {
+  detectClaudeCli,
+  launchClaude
+} from "./chunk-PXZBAC2M.js";
+import {
+  GitWorktreeManager
+} from "./chunk-QEPVTTHD.js";
+import {
+  SettingsManager
+} from "./chunk-JBH2ZYYZ.js";
+import {
+  executeGitCommand,
+  findMainWorktreePathWithSettings
+} from "./chunk-JQ7VOSTC.js";
+import "./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 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 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 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/MergeManager.ts
+var MergeManager = class {
+  constructor(settingsManager) {
+    this.settingsManager = settingsManager ?? new SettingsManager();
+  }
+  /**
+   * Get the main branch name from settings (defaults to 'main')
+   * @private
+   */
+  async getMainBranch() {
+    const settings = await this.settingsManager.loadSettings();
+    return settings.mainBranch ?? "main";
+  }
+  /**
+   * Rebase current branch on main with fail-fast on conflicts
+   * Ports bash/merge-and-clean.sh lines 781-913
+   *
+   * @param worktreePath - Path to the worktree
+   * @param options - Merge options (dryRun, force)
+   * @throws Error if main branch doesn't exist, uncommitted changes exist, or conflicts occur
+   */
+  async rebaseOnMain(worktreePath, options = {}) {
+    const { dryRun = false, force = false } = options;
+    const mainBranch = await this.getMainBranch();
+    logger.info(`Starting rebase on ${mainBranch} branch...`);
+    try {
+      await executeGitCommand(["show-ref", "--verify", "--quiet", `refs/heads/${mainBranch}`], {
+        cwd: worktreePath
+      });
+    } catch {
+      throw new Error(
+        `Main branch "${mainBranch}" does not exist. Cannot rebase.
+Ensure the repository has a "${mainBranch}" branch or create it first.`
+      );
+    }
+    const statusOutput = await executeGitCommand(["status", "--porcelain"], {
+      cwd: worktreePath
+    });
+    if (statusOutput.trim()) {
+      throw new Error(
+        "Uncommitted changes detected. Please commit or stash changes before rebasing.\nRun: git status to see uncommitted changes\nOr: il finish will automatically commit them for you"
+      );
+    }
+    const mergeBase = await executeGitCommand(["merge-base", mainBranch, "HEAD"], {
+      cwd: worktreePath
+    });
+    const mainHead = await executeGitCommand(["rev-parse", mainBranch], {
+      cwd: worktreePath
+    });
+    const mergeBaseTrimmed = mergeBase.trim();
+    const mainHeadTrimmed = mainHead.trim();
+    if (mergeBaseTrimmed === mainHeadTrimmed) {
+      logger.success(`Branch is already up to date with ${mainBranch}. No rebase needed.`);
+      return;
+    }
+    const commitsOutput = await executeGitCommand(["log", "--oneline", `${mainBranch}..HEAD`], {
+      cwd: worktreePath
+    });
+    const commits = commitsOutput.trim();
+    const commitLines = commits ? commits.split("\n") : [];
+    if (commits) {
+      logger.info(`Found ${commitLines.length} commit(s) to rebase:`);
+      commitLines.forEach((commit) => logger.info(`  ${commit}`));
+    } else {
+      logger.info(`${mainBranch} branch has moved forward. Rebasing to update branch...`);
+    }
+    if (!force && !dryRun) {
+      logger.info("Proceeding with rebase... (use --force to skip confirmations)");
+    }
+    if (dryRun) {
+      logger.info(`[DRY RUN] Would execute: git rebase ${mainBranch}`);
+      if (commitLines.length > 0) {
+        logger.info(`[DRY RUN] This would rebase ${commitLines.length} commit(s)`);
+      }
+      return;
+    }
+    try {
+      await executeGitCommand(["rebase", mainBranch], { cwd: worktreePath });
+      logger.success("Rebase completed successfully!");
+    } catch (error) {
+      const conflictedFiles = await this.detectConflictedFiles(worktreePath);
+      if (conflictedFiles.length > 0) {
+        logger.info("Merge conflicts detected, attempting Claude-assisted resolution...");
+        const resolved = await this.attemptClaudeConflictResolution(
+          worktreePath,
+          conflictedFiles
+        );
+        if (resolved) {
+          logger.success("Conflicts resolved with Claude assistance, rebase completed");
+          return;
+        }
+        const conflictError = this.formatConflictError(conflictedFiles);
+        throw new Error(conflictError);
+      }
+      throw new Error(
+        `Rebase failed: ${error instanceof Error ? error.message : String(error)}
+Run: git status for more details
+Or: git rebase --abort to cancel the rebase`
+      );
+    }
+  }
+  /**
+   * Validate that fast-forward merge is possible
+   * Ports bash/merge-and-clean.sh lines 957-968
+   *
+   * @param branchName - Name of the branch to merge
+   * @param mainWorktreePath - Path where main branch is checked out
+   * @throws Error if fast-forward is not possible
+   */
+  async validateFastForwardPossible(branchName, mainWorktreePath) {
+    const mainBranch = await this.getMainBranch();
+    const mergeBase = await executeGitCommand(["merge-base", mainBranch, branchName], {
+      cwd: mainWorktreePath
+    });
+    const mainHead = await executeGitCommand(["rev-parse", mainBranch], {
+      cwd: mainWorktreePath
+    });
+    const mergeBaseTrimmed = mergeBase.trim();
+    const mainHeadTrimmed = mainHead.trim();
+    if (mergeBaseTrimmed !== mainHeadTrimmed) {
+      throw new Error(
+        `Cannot perform fast-forward merge.
+The ${mainBranch} branch has moved forward since this branch was created.
+Merge base: ${mergeBaseTrimmed}
+Main HEAD:  ${mainHeadTrimmed}
+
+To fix this:
+  1. Rebase the branch on ${mainBranch}: git rebase ${mainBranch}
+  2. Or use: il finish to automatically rebase and merge
+`
+      );
+    }
+  }
+  /**
+   * Perform fast-forward only merge
+   * Ports bash/merge-and-clean.sh lines 938-994
+   *
+   * @param branchName - Name of the branch to merge
+   * @param worktreePath - Path to the worktree
+   * @param options - Merge options (dryRun, force)
+   * @throws Error if checkout, validation, or merge fails
+   */
+  async performFastForwardMerge(branchName, worktreePath, options = {}) {
+    const { dryRun = false, force = false } = options;
+    const mainBranch = await this.getMainBranch();
+    logger.info("Starting fast-forward merge...");
+    const mainWorktreePath = options.repoRoot ?? await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
+    logger.debug(`Using ${mainBranch} branch location: ${mainWorktreePath}`);
+    const currentBranch = await executeGitCommand(["branch", "--show-current"], {
+      cwd: mainWorktreePath
+    });
+    if (currentBranch.trim() !== mainBranch) {
+      throw new Error(
+        `Expected ${mainBranch} branch but found: ${currentBranch.trim()}
+At location: ${mainWorktreePath}
+This indicates the main worktree detection failed.`
+      );
+    }
+    await this.validateFastForwardPossible(branchName, mainWorktreePath);
+    const commitsOutput = await executeGitCommand(["log", "--oneline", `${mainBranch}..${branchName}`], {
+      cwd: mainWorktreePath
+    });
+    const commits = commitsOutput.trim();
+    if (!commits) {
+      logger.success(`Branch is already merged into ${mainBranch}. No merge needed.`);
+      return;
+    }
+    const commitLines = commits.split("\n");
+    logger.info(`Found ${commitLines.length} commit(s) to merge:`);
+    commitLines.forEach((commit) => logger.info(`  ${commit}`));
+    if (!force && !dryRun) {
+      logger.info("Proceeding with fast-forward merge... (use --force to skip confirmations)");
+    }
+    if (dryRun) {
+      logger.info(`[DRY RUN] Would execute: git merge --ff-only ${branchName}`);
+      logger.info(`[DRY RUN] This would merge ${commitLines.length} commit(s)`);
+      return;
+    }
+    try {
+      await executeGitCommand(["merge", "--ff-only", branchName], { cwd: mainWorktreePath });
+      logger.success(`Fast-forward merge completed! Merged ${commitLines.length} commit(s).`);
+    } catch (error) {
+      throw new Error(
+        `Fast-forward merge failed: ${error instanceof Error ? error.message : String(error)}
+
+To recover:
+  1. Check merge status: git status
+  2. Abort merge if needed: git merge --abort
+  3. Verify branch is rebased: git rebase main
+  4. Try merge again: il finish`
+      );
+    }
+  }
+  /**
+   * Helper: Detect conflicted files after failed rebase
+   * @private
+   */
+  async detectConflictedFiles(worktreePath) {
+    try {
+      const output = await executeGitCommand(["diff", "--name-only", "--diff-filter=U"], {
+        cwd: worktreePath
+      });
+      return output.trim().split("\n").filter((file) => file.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Helper: Format conflict error message with manual resolution steps
+   * @private
+   */
+  formatConflictError(conflictedFiles) {
+    const fileList = conflictedFiles.map((file) => `  \u2022 ${file}`).join("\n");
+    return "Rebase failed - merge conflicts detected in:\n" + fileList + "\n\nTo resolve manually:\n  1. Fix conflicts in the files above\n  2. Stage resolved files: git add <files>\n  3. Continue rebase: git rebase --continue\n  4. Or abort rebase: git rebase --abort\n  5. Then re-run: il finish <issue-number>";
+  }
+  /**
+   * Attempt to resolve conflicts using Claude
+   * Ports bash/merge-and-clean.sh lines 839-894
+   *
+   * @param worktreePath - Path to the worktree
+   * @param conflictedFiles - List of files with conflicts
+   * @returns true if conflicts resolved, false otherwise
+   * @private
+   */
+  async attemptClaudeConflictResolution(worktreePath, conflictedFiles) {
+    const isClaudeAvailable = await detectClaudeCli();
+    if (!isClaudeAvailable) {
+      logger.debug("Claude CLI not available, skipping conflict resolution");
+      return false;
+    }
+    logger.info(`Launching Claude to resolve conflicts in ${conflictedFiles.length} file(s)...`);
+    const prompt = `Please help resolve the git rebase conflicts in this repository. Analyze the conflicted files, understand the changes from both branches, fix the conflicts, then run 'git add .' to stage the resolved files, and finally run 'git rebase --continue' to continue the rebase process. Handle the entire workflow for me.`;
+    try {
+      await launchClaude(prompt, {
+        addDir: worktreePath,
+        headless: false
+        // Interactive - runs in current terminal with stdio: inherit
+      });
+      const remainingConflicts = await this.detectConflictedFiles(worktreePath);
+      if (remainingConflicts.length > 0) {
+        logger.warn(
+          `Conflicts still exist in ${remainingConflicts.length} file(s) after Claude assistance`
+        );
+        return false;
+      }
+      const rebaseInProgress = await this.isRebaseInProgress(worktreePath);
+      if (rebaseInProgress) {
+        logger.warn("Rebase still in progress after Claude assistance");
+        return false;
+      }
+      logger.success("Claude successfully resolved conflicts and completed rebase");
+      return true;
+    } catch (error) {
+      logger.warn("Claude conflict resolution failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  /**
+   * Check if a git rebase is currently in progress
+   * Checks for .git/rebase-merge or .git/rebase-apply directories
+   * Ports bash script logic from lines 853-856
+   *
+   * @param worktreePath - Path to the worktree
+   * @returns true if rebase in progress, false otherwise
+   * @private
+   */
+  async isRebaseInProgress(worktreePath) {
+    const fs = await import("fs/promises");
+    const path2 = await import("path");
+    const rebaseMergePath = path2.join(worktreePath, ".git", "rebase-merge");
+    const rebaseApplyPath = path2.join(worktreePath, ".git", "rebase-apply");
+    try {
+      await fs.access(rebaseMergePath);
+      return true;
+    } catch {
+    }
+    try {
+      await fs.access(rebaseApplyPath);
+      return true;
+    } catch {
+    }
+    return false;
+  }
+};
+
+// 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/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 = new NeonProvider({
+      projectId: process.env.NEON_PROJECT_ID ?? "",
+      parentBranch: process.env.NEON_PARENT_BRANCH ?? ""
+    });
+    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 parsed = await this.parseInput(input.identifier, input.options);
+      const worktrees = await this.validateInput(parsed, input.options);
+      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);
+        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) {
+    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);
+        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 settings = await this.settingsManager.loadSettings(worktree.path);
+        const skipVerify = ((_b = (_a = settings.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");
+    }
+    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 } = await import("./git-LVRZ57GJ.js");
+        await pushBranchToRemote(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}`);
+    }
+  }
+  /**
+   * 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);
+      }
+    } 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");
+      }
+    } 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)`);
+  }
+};
+export {
+  FinishCommand
+};
+//# sourceMappingURL=finish-CY4CIH6O.js.map