@iloom/cli 0.6.1 → 0.7.1

package/dist/chunk-YQNSZKKT.js

@@ -0,0 +1,822 @@
+#!/usr/bin/env node
+import {
+  detectPackageManager,
+  runScript
+} from "./chunk-RD7I2Q2F.js";
+import {
+  getPackageConfig,
+  hasScript
+} from "./chunk-XPKN3QWY.js";
+import {
+  executeGitCommand
+} from "./chunk-ZA575VLF.js";
+import {
+  promptCommitAction
+} from "./chunk-ZX3GTM7O.js";
+import {
+  detectClaudeCli,
+  launchClaude
+} from "./chunk-FP7G7DG3.js";
+import {
+  getLogger
+} from "./chunk-6MLEBAYZ.js";
+import {
+  logger
+} from "./chunk-VT4PDUYT.js";
+
+// src/lib/ValidationRunner.ts
+var ValidationRunner = class {
+  constructor() {
+  }
+  /**
+   * 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
+   * Prefers 'compile' script over 'typecheck' if both exist
+   */
+  async runTypecheck(worktreePath, dryRun) {
+    const stepStartTime = Date.now();
+    let scriptToRun = null;
+    try {
+      const pkgJson = await getPackageConfig(worktreePath);
+      const hasCompileScript = hasScript(pkgJson, "compile");
+      const hasTypecheckScript = hasScript(pkgJson, "typecheck");
+      if (hasCompileScript) {
+        scriptToRun = "compile";
+      } else if (hasTypecheckScript) {
+        scriptToRun = "typecheck";
+      }
+      if (!scriptToRun) {
+        getLogger().debug("Skipping typecheck - no compile or 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")) {
+        getLogger().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 ${scriptToRun}` : `${packageManager} ${scriptToRun}`;
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: scriptToRun,
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    getLogger().info(`Running ${scriptToRun}...`);
+    try {
+      await runScript(scriptToRun, worktreePath, [], { quiet: true });
+      getLogger().success(`${scriptToRun.charAt(0).toUpperCase() + scriptToRun.slice(1)} passed`);
+      return {
+        step: scriptToRun,
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    } catch {
+      const fixed = await this.attemptClaudeFix(
+        scriptToRun,
+        worktreePath,
+        packageManager
+      );
+      if (fixed) {
+        return {
+          step: scriptToRun,
+          passed: true,
+          skipped: false,
+          duration: Date.now() - stepStartTime
+        };
+      }
+      const runCommand = packageManager === "npm" ? `npm run ${scriptToRun}` : `${packageManager} ${scriptToRun}`;
+      const stepLabel = scriptToRun.charAt(0).toUpperCase() + scriptToRun.slice(1);
+      throw new Error(
+        `Error: ${stepLabel} 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 getPackageConfig(worktreePath);
+      const hasLintScript = hasScript(pkgJson, "lint");
+      if (!hasLintScript) {
+        getLogger().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")) {
+        getLogger().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`;
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: "lint",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    getLogger().info("Running lint...");
+    try {
+      await runScript("lint", worktreePath, [], { quiet: true });
+      getLogger().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 getPackageConfig(worktreePath);
+      const hasTestScript = hasScript(pkgJson, "test");
+      if (!hasTestScript) {
+        getLogger().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")) {
+        getLogger().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`;
+      getLogger().info(`[DRY RUN] Would run: ${command}`);
+      return {
+        step: "test",
+        passed: true,
+        skipped: false,
+        duration: Date.now() - stepStartTime
+      };
+    }
+    getLogger().info("Running tests...");
+    try {
+      await runScript("test", worktreePath, [], { quiet: true });
+      getLogger().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 ('compile' | '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) {
+      getLogger().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);
+    getLogger().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
+      });
+      getLogger().info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`);
+      try {
+        await runScript(validationType, worktreePath, [], { quiet: true });
+        getLogger().success(`${validationTypeCapitalized} passed after Claude auto-fix`);
+        return true;
+      } catch {
+        getLogger().warn(`${validationTypeCapitalized} still failing after Claude's help`);
+        return false;
+      }
+    } catch (error) {
+      getLogger().warn("Claude auto-fix failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  /**
+   * Get validation command string for prompts
+   * Uses il commands for multi-language project support
+   */
+  getValidationCommand(validationType, _packageManager) {
+    return `il ${validationType}`;
+  }
+  /**
+   * Get Claude prompt for specific validation type
+   * Matches bash script prompts exactly
+   */
+  getClaudePrompt(validationType, validationCommand) {
+    switch (validationType) {
+      case "compile":
+      case "typecheck":
+        return `There are TypeScript errors in this codebase. Please analyze the ${validationType} output, identify all type errors, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all type issues. When you are done, tell the user to quit using /exit to continue the validation process.`;
+      case "lint":
+        return `There are ESLint errors in this codebase. Please analyze the linting output, identify all linting issues, and fix them. Run '${validationCommand}' to see the errors, then make the necessary code changes to resolve all linting issues. Focus on code quality, consistency, and following the project's linting rules. When you are done, tell the user to quit using /exit to continue the validation process.`;
+      case "test":
+        return `There are unit test failures in this codebase. Please analyze the test output to understand what's failing, then fix the issues. This might involve updating test code, fixing bugs in the source code, or updating tests to match new behavior. Run '${validationCommand}' to see the detailed test failures, then make the necessary changes to get all tests passing. When you are done, tell the user to quit using /exit to continue the validation process.`;
+    }
+  }
+};
+
+// src/types/index.ts
+var UserAbortedCommitError = class extends Error {
+  constructor(message = "User aborted the commit") {
+    super(message);
+    this.name = "UserAbortedCommitError";
+  }
+};
+
+// src/utils/vscode.ts
+import { execa } from "execa";
+function isRunningInVSCode() {
+  return process.env.TERM_PROGRAM === "vscode";
+}
+function isRunningInCursor() {
+  return !!process.env.CURSOR_TRACE_ID;
+}
+function isRunningInAntigravity() {
+  return !!process.env.ANTIGRAVITY_CLI_ALIAS;
+}
+async function isVSCodeAvailable() {
+  try {
+    await execa("command", ["-v", "code"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("VSCode CLI not available", { error });
+    return false;
+  }
+}
+async function isCursorAvailable() {
+  try {
+    await execa("command", ["-v", "cursor"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Cursor CLI not available", { error });
+    return false;
+  }
+}
+async function isAntigravityAvailable() {
+  try {
+    await execa("command", ["-v", "agy"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Antigravity CLI not available", { error });
+    return false;
+  }
+}
+
+// src/lib/CommitManager.ts
+import { writeFile, readFile, unlink } from "fs/promises";
+import { join } from "path";
+import { execa as execa2 } from "execa";
+var CommitManager = class {
+  constructor() {
+  }
+  /**
+   * 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
+   * Returns the commit message that was used
+   */
+  async commitChanges(worktreePath, options) {
+    if (options.dryRun) {
+      getLogger().info("[DRY RUN] Would run: git add -A");
+      getLogger().info("[DRY RUN] Would generate commit message with Claude (if available)");
+      const fallbackMessage = this.generateFallbackMessage(options);
+      const verifyFlag = options.skipVerify ? " --no-verify" : "";
+      getLogger().info(`[DRY RUN] Would commit with message${verifyFlag}: ${fallbackMessage}`);
+      return { message: fallbackMessage };
+    }
+    await executeGitCommand(["add", "-A"], { cwd: worktreePath });
+    let message = null;
+    if (!options.message) {
+      try {
+        message = await this.generateClaudeCommitMessage(worktreePath, options.issueNumber, options.issuePrefix, options.trailerType);
+      } catch (error) {
+        getLogger().debug("Claude commit message generation failed, using fallback", { error });
+      }
+    }
+    message ??= this.generateFallbackMessage(options);
+    if (options.skipVerify && !options.skipVerifySilent) {
+      getLogger().warn("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 {
+        const action = await promptCommitAction(message);
+        if (action === "abort") {
+          throw new UserAbortedCommitError();
+        }
+        if (action === "accept") {
+          const commitArgs = ["commit", "-m", message];
+          if (options.skipVerify) {
+            commitArgs.push("--no-verify");
+          }
+          await executeGitCommand(commitArgs, { cwd: worktreePath });
+        } else {
+          getLogger().info("Opening editor for commit message review...");
+          if (isRunningInAntigravity() && await isAntigravityAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "agy", "Antigravity");
+          } else if (isRunningInCursor() && await isCursorAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "cursor", "Cursor");
+          } else if (isRunningInVSCode() && await isVSCodeAvailable()) {
+            await this.commitWithExternalEditor(worktreePath, message, options, "code", "VSCode");
+          } else {
+            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
+            });
+          }
+        }
+      }
+      return { message };
+    } catch (error) {
+      if (error instanceof UserAbortedCommitError) {
+        throw error;
+      }
+      if (error instanceof Error && error.message.includes("nothing to commit")) {
+        getLogger().info("No changes to commit");
+        return { message: "" };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Commit with external editor CLI (VSCode, Cursor, Antigravity, etc.)
+   * Handles file creation, editing, and commit to ensure the file opens
+   * in the current editor window (preserves IPC context)
+   */
+  async commitWithExternalEditor(worktreePath, message, options, cliCommand, editorName) {
+    const commitMsgPath = join(worktreePath, ".COMMIT_EDITMSG");
+    const initialContent = `${message}
+
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# Save and close the file to complete the commit.
+`;
+    await writeFile(commitMsgPath, initialContent, "utf-8");
+    try {
+      getLogger().debug(`Opening commit message in ${editorName}: ${commitMsgPath}`);
+      await execa2(cliCommand, ["--wait", commitMsgPath], {
+        cwd: worktreePath,
+        stdio: "inherit"
+      });
+      const editedContent = await readFile(commitMsgPath, "utf-8");
+      const finalMessage = editedContent.split("\n").filter((line) => !line.startsWith("#")).join("\n").trim();
+      if (!finalMessage) {
+        throw new UserAbortedCommitError();
+      }
+      const commitArgs = ["commit", "-F", commitMsgPath];
+      if (options.skipVerify) {
+        commitArgs.push("--no-verify");
+      }
+      await writeFile(commitMsgPath, finalMessage, "utf-8");
+      await executeGitCommand(commitArgs, { cwd: worktreePath });
+    } finally {
+      try {
+        await unlink(commitMsgPath);
+      } catch {
+      }
+    }
+  }
+  /**
+   * 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) {
+      const trailer = options.trailerType ?? "Fixes";
+      return `WIP: Auto-commit for issue ${options.issuePrefix}${options.issueNumber}
+
+${trailer} ${options.issuePrefix}${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 Code
+   * Claude examines the git repository directly via --add-dir option
+   * Returns null if Claude unavailable or fails validation
+   */
+  async generateClaudeCommitMessage(worktreePath, issueNumber, issuePrefix, trailerType) {
+    const startTime = Date.now();
+    if (getLogger().isDebugEnabled()) {
+      getLogger().debug("Claude commit message generation started", {
+        worktreePath: worktreePath.split("/").pop(),
+        // Just show the folder name for privacy
+        issueNumber
+      });
+    } else {
+      getLogger().info("Generating commit message with Claude...");
+    }
+    getLogger().debug("Checking Claude CLI availability...");
+    const isClaudeAvailable = await detectClaudeCli();
+    if (!isClaudeAvailable) {
+      getLogger().info("Claude CLI not available, skipping Claude commit message generation");
+      return null;
+    }
+    getLogger().debug("Claude CLI is available");
+    getLogger().debug("Building commit message prompt...");
+    const prompt = this.buildCommitMessagePrompt(issueNumber, issuePrefix, trailerType);
+    getLogger().debug("Prompt built", { promptLength: prompt.length });
+    getLogger().debug("Claude prompt content:", {
+      prompt,
+      truncatedPreview: prompt.substring(0, 500) + (prompt.length > 500 ? "...[truncated]" : "")
+    });
+    try {
+      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
+        appendSystemPrompt: "Output only the requested content. Never include preamble, analysis, or meta-commentary. Your response is used verbatim."
+      };
+      getLogger().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;
+      getLogger().debug("Claude API call completed", { duration: `${claudeDuration}ms` });
+      if (typeof result !== "string") {
+        getLogger().warn("Claude returned non-string result", { resultType: typeof result });
+        return null;
+      }
+      getLogger().debug("Raw Claude output received", {
+        outputLength: result.length,
+        preview: result.substring(0, 200) + (result.length > 200 ? "..." : "")
+      });
+      getLogger().debug("Sanitizing Claude output...");
+      const sanitized = this.sanitizeClaudeOutput(result);
+      getLogger().debug("Output sanitized", {
+        originalLength: result.length,
+        sanitizedLength: sanitized.length,
+        sanitized: sanitized.substring(0, 200) + (sanitized.length > 200 ? "..." : "")
+      });
+      if (!sanitized) {
+        getLogger().warn("Claude returned empty message after sanitization");
+        return null;
+      }
+      let finalMessage = sanitized;
+      if (issueNumber) {
+        const trailer = trailerType ?? "Fixes";
+        const trailerRef = `${trailer} ${issuePrefix}${issueNumber}`;
+        if (!finalMessage.includes(trailerRef)) {
+          finalMessage = `${finalMessage}
+
+${trailerRef}`;
+          getLogger().debug(`Added "${trailerRef}" trailer to commit message`);
+        } else {
+          getLogger().debug(`"${trailerRef}" already present in commit message`);
+        }
+      }
+      const totalDuration = Date.now() - startTime;
+      if (getLogger().isDebugEnabled()) {
+        getLogger().debug("Claude commit message generated", {
+          message: finalMessage,
+          totalDuration: `${totalDuration}ms`,
+          claudeApiDuration: `${claudeDuration}ms`
+        });
+      } else {
+        getLogger().info("Commit message generated");
+      }
+      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")) {
+        getLogger().warn("Claude commit message generation timed out after 45 seconds", {
+          totalDuration: `${totalDuration}ms`,
+          worktreePath: worktreePath.split("/").pop()
+        });
+      } else {
+        getLogger().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, issuePrefix, trailerType) {
+    const trailer = trailerType ?? "Fixes";
+    const issueContext = issueNumber ? `
+<IssueContext>
+This commit is associated with issue ${issuePrefix}${issueNumber}.
+${trailer === "Fixes" ? "If the changes appear to resolve the issue, include" : "Include"} "${trailer} ${issuePrefix}${issueNumber}" at the end of the first line of commit message.
+</IssueContext>` : "";
+    const examplePrefix = issuePrefix || "";
+    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 "${trailer} ${examplePrefix}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. ${trailer} ${examplePrefix}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;
+  }
+};
+
+export {
+  ValidationRunner,
+  UserAbortedCommitError,
+  CommitManager
+};
+//# sourceMappingURL=chunk-YQNSZKKT.js.map