@iloom/cli 0.1.17 → 0.1.19

package/dist/{finish-3CQZIULO.js → finish-QJSK6Z7J.js}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  MergeManager
+} from "./chunk-VVH3ANF2.js";
 import {
   ResourceCleanup
-} from "./chunk-CP2NU2JC.js";
+} from "./chunk-Q2KYPAH2.js";
 import {
   IdentifierParser
 } from "./chunk-H4E4THUZ.js";
@@ -12,16 +15,18 @@ import {
   CLIIsolationManager,
   DatabaseManager,
   EnvironmentManager
-} from "./chunk-HPJJSYNS.js";
-import "./chunk-37DYYFVK.js";
+} from "./chunk-H5LDRGVK.js";
+import {
+  loadEnvIntoProcess
+} from "./chunk-ZMNQBJUI.js";
 import {
   detectPackageManager,
   installDependencies,
   runScript
 } from "./chunk-BLCTGFZN.js";
 import {
-  NeonProvider
-} from "./chunk-YYSKGAZT.js";
+  createNeonProviderFromSettings
+} from "./chunk-LAPY6NAE.js";
 import {
   ProjectCapabilityDetector
 } from "./chunk-CWR2SANQ.js";
@@ -30,26 +35,27 @@ import {
   readPackageJson
 } from "./chunk-2ZPFJQ3B.js";
 import {
-  GitHubService
-} from "./chunk-T7QPXANZ.js";
-import "./chunk-KQDEK2ZW.js";
+  getConfiguredRepoFromSettings,
+  hasMultipleRemotes
+} from "./chunk-FXV24OYZ.js";
 import {
-  loadEnvIntoProcess
-} from "./chunk-SJUQ2NDR.js";
+  GitHubService
+} from "./chunk-ZWXJBSUW.js";
+import "./chunk-JXQXSC45.js";
 import {
   detectClaudeCli,
   launchClaude
 } from "./chunk-PXZBAC2M.js";
 import {
   GitWorktreeManager
-} from "./chunk-QEPVTTHD.js";
+} from "./chunk-IO4WFTL2.js";
 import {
   SettingsManager
-} from "./chunk-JBH2ZYYZ.js";
+} from "./chunk-VYQLLHZ7.js";
 import {
   executeGitCommand,
   findMainWorktreePathWithSettings
-} from "./chunk-JQ7VOSTC.js";
+} from "./chunk-KOCQAD2E.js";
 import "./chunk-JNKJ7NJV.js";
 import {
   logger
@@ -377,11 +383,11 @@ Run '${runCommand}' to see detailed errors.`
   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.`;
+        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 to continue the validation process.`;
+        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 to continue the validation process.`;
+        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.`;
     }
   }
 };
@@ -697,293 +703,6 @@ Start your response immediately with the commit message text.
   }
 };
 
-// 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) {
@@ -1096,10 +815,7 @@ var FinishCommand = class {
     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 neonProvider = createNeonProviderFromSettings(settings);
     const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
     const cliIsolationManager = new CLIIsolationManager();
     this.resourceCleanup = new ResourceCleanup(
@@ -1114,8 +830,15 @@ var FinishCommand = class {
    */
   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);
+      const worktrees = await this.validateInput(parsed, input.options, repo);
       logger.info(`Validated input: ${this.formatParsedInput(parsed)}`);
       const worktree = worktrees[0];
       if (!worktree) {
@@ -1125,7 +848,7 @@ var FinishCommand = class {
         if (!parsed.number) {
           throw new Error("Invalid PR number");
         }
-        const pr = await this.gitHubService.fetchPR(parsed.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);
@@ -1251,7 +974,7 @@ var FinishCommand = class {
   /**
    * Validate the parsed input based on its type
    */
-  async validateInput(parsed, options) {
+  async validateInput(parsed, options, repo) {
     switch (parsed.type) {
       case "pr": {
         if (!parsed.number) {
@@ -1265,7 +988,7 @@ var FinishCommand = class {
         if (!parsed.number) {
           throw new Error("Invalid issue number");
         }
-        const issue = await this.gitHubService.fetchIssue(parsed.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.`
@@ -1466,7 +1189,7 @@ 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-LVRZ57GJ.js");
+        const { pushBranchToRemote } = await import("./git-OUYMVYJX.js");
         await pushBranchToRemote(pr.branch, worktree.path, {
           dryRun: false
         });
@@ -1629,4 +1352,4 @@ var FinishCommand = class {
 export {
   FinishCommand
 };
-//# sourceMappingURL=finish-3CQZIULO.js.map
+//# sourceMappingURL=finish-QJSK6Z7J.js.map