@iloom/cli 0.1.19 → 0.2.0

package/dist/{finish-QJSK6Z7J.js → finish-TX5CJICB.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   MergeManager
-} from "./chunk-VVH3ANF2.js";
+} from "./chunk-4IV6W4U5.js";
 import {
   ResourceCleanup
-} from "./chunk-Q2KYPAH2.js";
+} from "./chunk-SYOSCMIT.js";
 import {
   IdentifierParser
 } from "./chunk-H4E4THUZ.js";
@@ -34,29 +34,39 @@ import {
   hasScript,
   readPackageJson
 } from "./chunk-2ZPFJQ3B.js";
+import {
+  openBrowser
+} from "./chunk-YETJNRQM.js";
 import {
   getConfiguredRepoFromSettings,
-  hasMultipleRemotes
-} from "./chunk-FXV24OYZ.js";
+  getEffectivePRTargetRemote,
+  hasMultipleRemotes,
+  parseGitRemotes
+} from "./chunk-DJUGYNQE.js";
 import {
   GitHubService
-} from "./chunk-ZWXJBSUW.js";
-import "./chunk-JXQXSC45.js";
+} from "./chunk-TS6DL67T.js";
+import {
+  executeGhCommand
+} from "./chunk-SWCRXDZC.js";
 import {
   detectClaudeCli,
   launchClaude
-} from "./chunk-PXZBAC2M.js";
+} from "./chunk-MFU53H6J.js";
 import {
   GitWorktreeManager
-} from "./chunk-IO4WFTL2.js";
+} from "./chunk-VETG35MF.js";
 import {
   SettingsManager
-} from "./chunk-VYQLLHZ7.js";
+} from "./chunk-T3KEIB4D.js";
 import {
   executeGitCommand,
-  findMainWorktreePathWithSettings
-} from "./chunk-KOCQAD2E.js";
-import "./chunk-JNKJ7NJV.js";
+  findMainWorktreePathWithSettings,
+  pushBranchToRemote
+} from "./chunk-HBVFXN7R.js";
+import {
+  promptConfirmation
+} from "./chunk-JNKJ7NJV.js";
 import {
   logger
 } from "./chunk-GEHQXLEI.js";
@@ -781,6 +791,267 @@ 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 {
@@ -1107,8 +1378,8 @@ var FinishCommand = class {
         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 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
@@ -1122,6 +1393,12 @@ var FinishCommand = class {
     } 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,
@@ -1189,8 +1466,8 @@ var FinishCommand = class {
         logger.info(`[DRY RUN] Would push changes to origin/${pr.branch}`);
       } else {
         logger.info("Pushing changes to remote...");
-        const { pushBranchToRemote } = await import("./git-OUYMVYJX.js");
-        await pushBranchToRemote(pr.branch, worktree.path, {
+        const { pushBranchToRemote: pushBranchToRemote2 } = await import("./git-WC6HZLOT.js");
+        await pushBranchToRemote2(pr.branch, worktree.path, {
           dryRun: false
         });
         logger.success(`Changes pushed to PR #${parsed.number}`);
@@ -1200,6 +1477,123 @@ var FinishCommand = class {
       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
@@ -1352,4 +1746,4 @@ var FinishCommand = class {
 export {
   FinishCommand
 };
-//# sourceMappingURL=finish-QJSK6Z7J.js.map
+//# sourceMappingURL=finish-TX5CJICB.js.map