@pourkit/cli 0.0.0-next-20260620201514 → 0.0.0-next-20260621003351

package/dist/cli.js

@@ -7037,157 +7037,171 @@ async function handlePublishedHistoryRisk(failure, context) {
   throw new Error(message);
 }
 
-// commands/issue.ts
-var HumanHandoffStop = class extends Error {
+// issues/issue-run-lifecycle.ts
+var IssueRunHumanHandoffStop = class extends Error {
   constructor(message) {
     super(message);
     this.name = "HumanHandoffStop";
   }
 };
-async function runIssueCommand(options) {
-  const {
-    issueNumber,
-    config,
-    issueProvider,
-    prProvider,
-    executionProvider,
-    logger
-  } = options;
-  const ROOT = options.repoRoot;
-  let executionSession;
+async function runIssueLifecycle(options) {
   try {
-    executionSession = await executionProvider.createSession?.();
-    const runOptions = executionSession ? { ...options, executionProvider: executionSession } : options;
-    const startResult = await startIssueRun(runOptions);
-    const {
-      issue,
-      parentPrdIssue,
-      target,
-      effectiveTarget,
-      branchName,
-      worktreeState,
-      executionResult
-    } = startResult;
+    const startResult = await options.deps.startIssueRun(options.runOptions);
+    const reviewAlreadyPassed = startResult.worktreeState?.review.lastVerdict && !startResult.worktreeState.review.exhaustedPreviousRun && (startResult.worktreeState.review.lastVerdict === "PASS" || startResult.worktreeState.review.lastVerdict === "PASS_WITH_NOTES");
     let reviewArtifactPath;
-    const reviewAlreadyPassed = worktreeState?.review.lastVerdict && ["PASS", "PASS_WITH_NOTES"].includes(worktreeState.review.lastVerdict) && !worktreeState.review.exhaustedPreviousRun;
     if (reviewAlreadyPassed) {
-      reviewArtifactPath = worktreeState.review.lastArtifactPath;
+      reviewArtifactPath = startResult.worktreeState.review.lastArtifactPath;
     } else {
-      const lifetimeIterationsFromState = worktreeState?.review.lifetimeIterations ?? 0;
-      const humanHandoffResolved = worktreeState?.review.lastVerdict === "NEEDS_HUMAN";
-      const reviewResult = await advanceIssueRunReview({
-        executionProvider: runOptions.executionProvider,
-        config,
-        target: effectiveTarget,
-        issue,
-        parentPrdIssue,
-        builderBranch: branchName,
-        worktreePath: executionResult.worktreePath,
-        repoRoot: ROOT,
-        logger,
-        startingLifetimeIteration: lifetimeIterationsFromState,
-        humanHandoffResolved,
+      const reviewResult = await options.deps.advanceIssueRunReview({
+        executionProvider: options.runOptions.executionProvider,
+        config: options.config,
+        target: startResult.effectiveTarget,
+        issue: startResult.issue,
+        parentPrdIssue: startResult.parentPrdIssue,
+        builderBranch: startResult.branchName,
+        worktreePath: startResult.executionResult.worktreePath,
+        repoRoot: options.repoRoot,
+        logger: options.logger,
+        startingLifetimeIteration: startResult.worktreeState?.review.lifetimeIterations ?? 0,
+        humanHandoffResolved: startResult.worktreeState?.review.lastVerdict === "NEEDS_HUMAN",
         serena: startResult.serena,
         memory: startResult.memory
       });
       if (reviewResult.exhaustedMaxIterations) {
         throw new Error(
-          `Max review iterations (${reviewResult.iterations}) exhausted`
+          "Review loop exhausted maximum iterations without passing"
         );
       }
       if (reviewResult.verdict === "FAIL") {
-        throw new Error(`Review failed with FAIL verdict`);
+        const summary = reviewResult.output?.trim() || "no summary provided";
+        throw new Error(`Review loop failed: ${summary}`);
       }
       if (reviewResult.verdict === "NEEDS_HUMAN") {
-        await transitionIssueToHumanHandoff({
-          issueProvider,
-          issueNumber,
-          config,
-          logger,
+        await options.deps.transitionReviewNeedsHumanToHandoff({
+          issueProvider: options.issueProvider,
+          issueNumber: options.issueNumber,
+          config: options.config,
+          logger: options.logger,
           reviewResult
         });
-        throw new HumanHandoffStop(
-          `Review requires human handoff: NEEDS_HUMAN verdict`
+        throw new IssueRunHumanHandoffStop(
+          "Review requires human handoff: NEEDS_HUMAN verdict"
         );
       }
       reviewArtifactPath = reviewResult.artifactPath;
     }
-    const finalReviewResult = await advanceIssueFinalReview({
-      executionProvider: runOptions.executionProvider,
-      config,
-      target: effectiveTarget,
-      issue,
-      parentPrdIssue,
-      builderBranch: branchName,
-      worktreePath: executionResult.worktreePath,
-      repoRoot: ROOT,
-      logger,
+    const finalReviewResult = await options.deps.advanceIssueFinalReview({
+      executionProvider: options.runOptions.executionProvider,
+      config: options.config,
+      target: startResult.effectiveTarget,
+      issue: startResult.issue,
+      parentPrdIssue: startResult.parentPrdIssue,
+      builderBranch: startResult.branchName,
+      worktreePath: startResult.executionResult.worktreePath,
+      repoRoot: options.repoRoot,
+      logger: options.logger,
       reviewArtifactPath,
-      worktreeState,
+      worktreeState: startResult.worktreeState,
       memory: startResult.memory
     });
     if (finalReviewResult.verdict === "needs_human_review") {
-      const transitions = createIssueTransitions(
-        {
-          fetchIssue: issueProvider.fetchIssue.bind(issueProvider),
-          addLabels: issueProvider.addLabels.bind(issueProvider),
-          removeLabel: issueProvider.removeLabel.bind(issueProvider),
-          closeIssue: issueProvider.closeIssue.bind(issueProvider)
-        },
-        {
-          blocked: config.labels.blocked,
-          readyForAgent: config.labels.readyForAgent,
-          needsTriage: config.labels.needsTriage,
-          agentInProgress: config.labels.agentInProgress,
-          readyForHuman: config.labels.readyForHuman,
-          prOpenAwaitingMerge: config.labels.prOpenAwaitingMerge
-        }
-      );
-      await transitions.moveToReadyForHuman(issueNumber);
-      const comment = [
-        "Pourkit stopped the Issue Final Review because human review is needed.",
-        "",
-        finalReviewResult.needsHumanReason,
-        "",
-        "Artifacts:",
-        `- Issue Final Review: ${finalReviewResult.artifactPath}`
-      ].join("\n");
-      await issueProvider.commentIssue(issueNumber, comment);
-      logger.step(
-        "info",
-        `Issue Final Review requires human handoff for issue ${issueNumber}`
-      );
-      throw new HumanHandoffStop(
+      await options.deps.transitionIssueFinalReviewNeedsHumanToHandoff({
+        issueNumber: options.issueNumber,
+        finalReviewResult
+      });
+      throw new IssueRunHumanHandoffStop(
         `Issue Final Review requires human handoff: ${finalReviewResult.needsHumanReason}`
       );
     }
-    return await completeIssueRun({
-      ...runOptions,
+    return await options.deps.completeIssueRun({
+      ...options.runOptions,
       startResult,
       reviewArtifactPath
     });
   } catch (error) {
-    if (error instanceof HumanHandoffStop) {
+    if (error instanceof IssueRunHumanHandoffStop) {
       throw error;
     }
     if (error instanceof Error && "_tag" in error) {
-      await failIssueRun({
-        issueProvider,
-        issueNumber,
-        config,
-        logger,
+      await options.deps.failIssueRun({
+        issueProvider: options.issueProvider,
+        issueNumber: options.issueNumber,
+        config: options.config,
+        logger: options.logger,
         error: `[${error._tag}] ${error.message}`
       });
     } else {
-      await failIssueRun({
-        issueProvider,
-        issueNumber,
-        config,
-        logger,
+      await options.deps.failIssueRun({
+        issueProvider: options.issueProvider,
+        issueNumber: options.issueNumber,
+        config: options.config,
+        logger: options.logger,
         error: error instanceof Error ? error : String(error)
       });
     }
     throw error;
+  }
+}
+
+// commands/issue.ts
+async function runIssueCommand(options) {
+  const { issueNumber, config, issueProvider, executionProvider, logger } = options;
+  const ROOT = options.repoRoot;
+  let executionSession;
+  try {
+    executionSession = await executionProvider.createSession?.();
+    const runOptions = executionSession ? { ...options, executionProvider: executionSession } : options;
+    return await runIssueLifecycle({
+      issueNumber,
+      config,
+      issueProvider,
+      logger,
+      repoRoot: ROOT,
+      runOptions,
+      deps: {
+        startIssueRun,
+        advanceIssueRunReview,
+        advanceIssueFinalReview,
+        completeIssueRun,
+        failIssueRun,
+        transitionReviewNeedsHumanToHandoff: transitionIssueToHumanHandoff,
+        transitionIssueFinalReviewNeedsHumanToHandoff: async ({
+          issueNumber: issueNumber2,
+          finalReviewResult
+        }) => {
+          const transitions = createIssueTransitions(
+            {
+              fetchIssue: issueProvider.fetchIssue.bind(issueProvider),
+              addLabels: issueProvider.addLabels.bind(issueProvider),
+              removeLabel: issueProvider.removeLabel.bind(issueProvider),
+              closeIssue: issueProvider.closeIssue.bind(issueProvider)
+            },
+            {
+              blocked: config.labels.blocked,
+              readyForAgent: config.labels.readyForAgent,
+              needsTriage: config.labels.needsTriage,
+              agentInProgress: config.labels.agentInProgress,
+              readyForHuman: config.labels.readyForHuman,
+              prOpenAwaitingMerge: config.labels.prOpenAwaitingMerge
+            }
+          );
+          await transitions.moveToReadyForHuman(issueNumber2);
+          const comment = [
+            "Pourkit stopped the Issue Final Review because human review is needed.",
+            "",
+            finalReviewResult.needsHumanReason,
+            "",
+            "Artifacts:",
+            `- Issue Final Review: ${finalReviewResult.artifactPath}`
+          ].join("\n");
+          await issueProvider.commentIssue(issueNumber2, comment);
+          logger.step(
+            "info",
+            `Issue Final Review requires human handoff for issue ${issueNumber2}`
+          );
+        }
+      }
+    });
   } finally {
     await executionSession?.close();
   }
@@ -15444,11 +15458,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260620201514")) {
-    return "0.0.0-next-20260620201514";
+  if (isPackageVersion("0.0.0-next-20260621003351")) {
+    return "0.0.0-next-20260621003351";
   }
-  if (isReleaseVersion("0.0.0-next-20260620201514")) {
-    return "0.0.0-next-20260620201514";
+  if (isReleaseVersion("0.0.0-next-20260621003351")) {
+    return "0.0.0-next-20260621003351";
   }
   try {
     const root = repoRoot();