@kody-ade/kody-engine 0.1.4 → 0.1.6

package/dist/bin/cli.mjs

@@ -7965,10 +7965,16 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
     }
     if (!ctx.input.dryRun && !ctx.input.local) {
       try {
-        const currentBranch = execFileSync13("git", ["branch", "--show-current"], {
-          encoding: "utf-8"
-        }).trim();
-        const isFeatureBranch = !["dev", "main", "master"].includes(currentBranch);
+        const currentBranch = execFileSync13(
+          "git",
+          ["branch", "--show-current"],
+          {
+            encoding: "utf-8"
+          }
+        ).trim();
+        const isFeatureBranch = !["dev", "main", "master"].includes(
+          currentBranch
+        );
         if (isFeatureBranch) {
           commitPipelineFiles({
             taskDir: ctx.taskDir,
@@ -7981,7 +7987,10 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
           logger.info("  \u2713 Pushed fresh running status.json to branch");
         }
       } catch (earlyPushErr) {
-        logger.warn({ err: earlyPushErr }, "Early status push failed (non-fatal)");
+        logger.warn(
+          { err: earlyPushErr },
+          "Early status push failed (non-fatal)"
+        );
       }
     }
   } else {
@@ -8002,7 +8011,9 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
       }
     }
     if (state.state === "paused") {
-      const anyPausedStage = Object.values(state.stages).some((s) => s.state === "paused");
+      const anyPausedStage = Object.values(state.stages).some(
+        (s) => s.state === "paused"
+      );
       if (!anyPausedStage) {
         state = {
           ...state,
@@ -8035,7 +8046,11 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
         const recoveredState = recoverStaleStages(currentState);
         if (recoveredState !== currentState) {
           logger.info("\u26A0\uFE0F Periodic recovery: reset stale running stages");
-          logRecovery("stale-stage-recovery", ctx.taskId, "Reset stale running stages");
+          logRecovery(
+            "stale-stage-recovery",
+            ctx.taskId,
+            "Reset stale running stages"
+          );
           state = recoveredState;
           writeState(ctx.taskId, state);
         }
@@ -8047,7 +8062,10 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
       const newOrder = flattenPipelineOrder(pipeline.order);
       for (const stageName of newOrder) {
         if (!state.stages[stageName]) {
-          state = updateStage(state, stageName, { state: "pending", retries: 0 });
+          state = updateStage(state, stageName, {
+            state: "pending",
+            retries: 0
+          });
         }
       }
       writeState(ctx.taskId, state);
@@ -8088,7 +8106,9 @@ async function runPipeline(ctx, pipeline, hooks, rebuildPipeline) {
     const stageState = failedStage?.[1];
     const stageOutcome = stageState?.state || "unknown";
     const stageError = stageState?.error ? `: ${stageState.error}` : "";
-    throw new Error(`Pipeline failed at stage: ${stageName} (${stageOutcome})${stageError}`);
+    throw new Error(
+      `Pipeline failed at stage: ${stageName} (${stageOutcome})${stageError}`
+    );
   }
   return state;
 }
@@ -8134,7 +8154,10 @@ async function executeSingleStep(ctx, pipeline, state, stageName) {
     logger.info(`  ${stageName} already completed, skipping`);
     return state;
   }
-  state = updateStage(state, stageName, { state: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  state = updateStage(state, stageName, {
+    state: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
   writeState(ctx.taskId, state);
   logStageStart(stageName, ctx.taskId);
   if (ctx.input.dryRun) {
@@ -8156,7 +8179,35 @@ async function executeSingleStep(ctx, pipeline, state, stageName) {
     const handler = getHandler(def.name, def.type);
     const result = await handler.execute(ctx, def);
     ciGroupEnd();
-    return await handleStageResult(ctx, pipeline, state, stageName, result, def);
+    if (result.outcome === "failed" || result.outcome === "timed_out") {
+      if (def.postActions && !ctx.input.dryRun) {
+        try {
+          for (const action of def.postActions) {
+            await executePostAction(ctx, action, state);
+          }
+        } catch (postError) {
+          logger.error(
+            { err: postError },
+            `  Post-action failed for ${stageName}:`
+          );
+        }
+      }
+      const errorMessage = `${stageName} ${result.outcome === "timed_out" ? "timed out" : "failed"}: ${result.reason || "unknown"}`;
+      throw new StageError(
+        errorMessage,
+        stageName,
+        void 0,
+        result.sessionId
+      );
+    }
+    return await handleStageResult(
+      ctx,
+      pipeline,
+      state,
+      stageName,
+      result,
+      def
+    );
   } catch (error) {
     ciGroupEnd();
     if (error instanceof PipelinePausedError) {
@@ -8166,14 +8217,16 @@ async function executeSingleStep(ctx, pipeline, state, stageName) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger.error({ err: error }, `  \u274C ${stageName} failed:`);
     logStageFail(stageName, ctx.taskId, errorMessage);
-    const canObserve = ctx.serverUrl && ctx.lastSessionId && !ctx.input.dryRun;
+    const stageSessionId = error instanceof StageError ? error.sessionId : void 0;
+    const effectiveSessionId = stageSessionId || ctx.lastSessionId;
+    const canObserve = ctx.serverUrl && effectiveSessionId && !ctx.input.dryRun;
     if (canObserve && !def.advisory) {
       try {
         const observer = new PipelineObserver(
           ctx.taskId,
           ctx.taskDir,
           ctx.serverUrl,
-          ctx.lastSessionId,
+          effectiveSessionId,
           ctx.taskDir
           // dataDir is taskDir/opencode-data derived in Observer
         );
@@ -8214,7 +8267,10 @@ async function executeSingleStep(ctx, pipeline, state, stageName) {
             return completeState(state, "failed");
         }
       } catch (observerError) {
-        logger.error({ err: observerError }, `[StateMachine] Observer error, falling back`);
+        logger.error(
+          { err: observerError },
+          `[StateMachine] Observer error, falling back`
+        );
         state = updateStage(state, stageName, {
           state: "failed",
           error: errorMessage
@@ -8261,7 +8317,10 @@ async function executeParallelStep(ctx, pipeline, state, stageNames) {
     stagesToRun.map(async (stageName) => {
       const def = pipeline.stages.get(stageName);
       if (!def) {
-        throw new StageError(`Stage '${stageName}' not found in pipeline definitions`, stageName);
+        throw new StageError(
+          `Stage '${stageName}' not found in pipeline definitions`,
+          stageName
+        );
       }
       if (def.shouldSkip) {
         const skipResult = def.shouldSkip(ctx);
@@ -8360,7 +8419,10 @@ async function executeParallelStep(ctx, pipeline, state, stageNames) {
             pausedStage = stageName;
             continue;
           }
-          logger.error({ err: postError }, `  Post-action failed for parallel stage ${stageName}:`);
+          logger.error(
+            { err: postError },
+            `  Post-action failed for parallel stage ${stageName}:`
+          );
           const postErrorMsg = postError instanceof Error ? postError.message : String(postError);
           state = updateStage(state, stageName, {
             state: "failed",
@@ -8386,7 +8448,10 @@ async function executeParallelStep(ctx, pipeline, state, stageNames) {
         error: stageResult.reason || "timed out"
       });
       if (!isAdvisory) {
-        criticalFailures.push({ name: stageName, reason: stageResult.reason || "timed out" });
+        criticalFailures.push({
+          name: stageName,
+          reason: stageResult.reason || "timed out"
+        });
       }
     } else if (stageResult.outcome === "failed") {
       const isAdvisory = pipeline.stages.get(stageName)?.advisory === true;
@@ -8395,20 +8460,28 @@ async function executeParallelStep(ctx, pipeline, state, stageNames) {
           state: "failed",
           error: stageResult.reason || "failed"
         });
-        advisoryFailures.push({ name: stageName, reason: stageResult.reason || "failed" });
+        advisoryFailures.push({
+          name: stageName,
+          reason: stageResult.reason || "failed"
+        });
       } else {
         state = updateStage(state, stageName, {
           state: "failed",
           error: stageResult.reason || "failed"
         });
-        criticalFailures.push({ name: stageName, reason: stageResult.reason || "failed" });
+        criticalFailures.push({
+          name: stageName,
+          reason: stageResult.reason || "failed"
+        });
       }
     }
   }
   if (criticalFailures.length > 0) {
     const errors = criticalFailures.map((f) => f.reason).join("; ");
     const names = criticalFailures.map((f) => f.name);
-    logger.error(`  \u274C Parallel stages [${names.join(", ")}] failed: ${errors}`);
+    logger.error(
+      `  \u274C Parallel stages [${names.join(", ")}] failed: ${errors}`
+    );
     if (ctx.input.issueNumber) {
       setLifecycleLabel(ctx.input.issueNumber, "kody:failed");
     }
@@ -8434,7 +8507,12 @@ async function handleStageResult(ctx, pipeline, state, stageName, result, def) {
       cost: result.cost,
       sessionId: result.sessionId
     });
-    logStageComplete(stageName, ctx.taskId, "completed", elapsed ? elapsed * 1e3 : void 0);
+    logStageComplete(
+      stageName,
+      ctx.taskId,
+      "completed",
+      elapsed ? elapsed * 1e3 : void 0
+    );
     if (result.sessionId) {
       ctx.lastSessionId = result.sessionId;
     }
@@ -8526,11 +8604,13 @@ var init_state_machine = __esm({
     StageError = class extends Error {
       stageName;
       cause;
-      constructor(message, stageName, cause) {
+      sessionId;
+      constructor(message, stageName, cause, sessionId) {
         super(message);
         this.name = "StageError";
         this.stageName = stageName;
         this.cause = cause;
+        this.sessionId = sessionId;
       }
     };
   }