karajan-code 1.10.0 → 1.11.0

package/src/utils/rate-limit-detector.js

@@ -1,9 +1,69 @@
 /**
  * Detects rate limit / usage cap messages from CLI agent output.
- * Returns { isRateLimit, agent, message } where agent is the best guess
- * of which CLI triggered it (or "unknown").
+ * Returns { isRateLimit, agent, message, cooldownUntil, cooldownMs }
+ * where agent is the best guess of which CLI triggered it (or "unknown").
  */
 
+/**
+ * Extracts cooldown timing from a rate limit message string.
+ * Returns { cooldownUntil, cooldownMs } where cooldownUntil is an ISO string
+ * and cooldownMs is milliseconds to wait, or both null if not found.
+ */
+export function parseCooldown(message) {
+  if (!message || typeof message !== "string") {
+    return { cooldownUntil: null, cooldownMs: null };
+  }
+
+  // 1. ISO timestamp: "try again after 2026-03-07T15:30:00Z"
+  //    Also: "resets at 2026-03-07T15:30:00Z"
+  const isoMatch = message.match(
+    /(?:after|at)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)/i
+  );
+  if (isoMatch) {
+    const target = new Date(isoMatch[1]);
+    if (!isNaN(target.getTime())) {
+      const ms = Math.max(0, target.getTime() - Date.now());
+      return { cooldownUntil: target.toISOString(), cooldownMs: ms };
+    }
+  }
+
+  // 4. Claude specific: "resets at 2026-03-07 15:30 UTC" (space-separated date/time)
+  const resetMatch = message.match(
+    /resets?\s+at\s+(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})\s*UTC/i
+  );
+  if (resetMatch) {
+    const target = new Date(`${resetMatch[1]}T${resetMatch[2]}:00Z`);
+    if (!isNaN(target.getTime())) {
+      const ms = Math.max(0, target.getTime() - Date.now());
+      return { cooldownUntil: target.toISOString(), cooldownMs: ms };
+    }
+  }
+
+  // 2. Relative seconds: "retry after 120 seconds" / "retry in 120s" / "Retry-After: 120"
+  const secMatch = message.match(
+    /(?:retry[\s-]*after|retry\s+in|wait)\s*:?\s*(\d+)\s*(?:seconds?|secs?|s\b)/i
+  ) || message.match(/Retry-After:\s*(\d+)/i);
+  if (secMatch) {
+    const seconds = parseInt(secMatch[1], 10);
+    const ms = seconds * 1000;
+    const target = new Date(Date.now() + ms);
+    return { cooldownUntil: target.toISOString(), cooldownMs: ms };
+  }
+
+  // 3. Relative minutes: "retry in 5 minutes" / "wait 5 min"
+  const minMatch = message.match(
+    /(?:retry\s+in|wait|after)\s+(\d+)\s*(?:minutes?|mins?)/i
+  );
+  if (minMatch) {
+    const minutes = parseInt(minMatch[1], 10);
+    const ms = minutes * 60 * 1000;
+    const target = new Date(Date.now() + ms);
+    return { cooldownUntil: target.toISOString(), cooldownMs: ms };
+  }
+
+  return { cooldownUntil: null, cooldownMs: null };
+}
+
 const RATE_LIMIT_PATTERNS = [
   // Claude CLI
   { pattern: /usage limit/i, agent: "claude" },
@@ -34,10 +94,11 @@ export function detectRateLimit({ stderr = "", stdout = "" }) {
       return {
         isRateLimit: true,
         agent,
-        message: matchedLine.trim()
+        message: matchedLine.trim(),
+        ...parseCooldown(matchedLine)
       };
     }
   }
 
-  return { isRateLimit: false, agent: "", message: "" };
+  return { isRateLimit: false, agent: "", message: "", cooldownUntil: null, cooldownMs: null };
 }

package/src/utils/run-log.js

@@ -40,6 +40,9 @@ function formatLine(event) {
   if (event.detail?.silenceMs !== undefined) extra.push(`silence=${Math.round(event.detail.silenceMs / 1000)}s`);
   if (event.detail?.severity) extra.push(`severity=${event.detail.severity}`);
   if (event.detail?.stream) extra.push(`stream=${event.detail.stream}`);
+  if (event.detail?.cooldownUntil) extra.push(`until=${event.detail.cooldownUntil}`);
+  if (event.detail?.retryCount !== undefined) extra.push(`retry=${event.detail.retryCount}/${event.detail.maxRetries || "?"}`);
+  if (event.detail?.remainingMs !== undefined) extra.push(`remaining=${Math.round(event.detail.remainingMs / 1000)}s`);
 
   const extraStr = extra.length ? ` (${extra.join(", ")})` : "";
   return `${ts} [${type}] ${stage ? `[${stage}] ` : ""}${msg}${extraStr}`;
@@ -96,9 +99,78 @@ export function createRunLog(projectDir) {
   };
 }
 
+/**
+ * Parse the run log to extract current status information.
+ */
+function parseRunStatus(lines) {
+  const status = {
+    currentStage: null,
+    currentAgent: null,
+    startedAt: null,
+    isRunning: false,
+    lastEvent: null,
+    iteration: null,
+    errors: []
+  };
+
+  for (const line of lines) {
+    // Detect run start
+    if (line.includes("[kj_run] started") || line.includes("[kj_code] started") || line.includes("[kj_plan] started")) {
+      status.isRunning = true;
+      const tool = line.includes("kj_run") ? "kj_run" : line.includes("kj_code") ? "kj_code" : "kj_plan";
+      status.currentStage = tool;
+      const tsMatch = line.match(/^(\d{2}:\d{2}:\d{2}\.\d{3})/);
+      if (tsMatch) status.startedAt = tsMatch[1];
+    }
+
+    // Detect run finish
+    if (line.includes("[kj_run] finished") || line.includes("[kj_code] finished") || line.includes("[kj_plan] finished") || line.includes("finished")) {
+      if (line.includes("[kj_run]") || line.includes("[kj_code]") || line.includes("[kj_plan]")) {
+        status.isRunning = false;
+      }
+    }
+
+    // Detect stage transitions
+    const stageStart = line.match(/\[(\w+):start\]/);
+    if (stageStart) {
+      status.currentStage = stageStart[1];
+    }
+    const stageDone = line.match(/\[(\w+):done\]|\[(\w+)\] finished/);
+    if (stageDone) {
+      const doneName = stageDone[1] || stageDone[2];
+      if (doneName === status.currentStage) status.currentStage = "idle";
+    }
+
+    // Detect agent
+    const agentMatch = line.match(/agent=(\w+)/);
+    if (agentMatch) status.currentAgent = agentMatch[1];
+
+    // Detect iteration
+    const iterMatch = line.match(/[Ii]teration\s+(\d+)/);
+    if (iterMatch) status.iteration = parseInt(iterMatch[1], 10);
+
+    // Detect errors
+    if (line.match(/\[.*:fail\]|\[.*error\]/i) || line.includes("ERROR")) {
+      status.errors.push(line.trim());
+    }
+
+    // Detect standby
+    if (line.includes("[standby]") || line.includes("standby")) {
+      status.currentStage = "standby";
+    }
+
+    status.lastEvent = line.trim();
+  }
+
+  // Keep only last 3 errors
+  if (status.errors.length > 3) status.errors = status.errors.slice(-3);
+
+  return status;
+}
+
 /**
  * Read the current run log contents.
- * Returns the last N lines (default 50).
+ * Returns the last N lines (default 50) plus a parsed status summary.
  */
 export function readRunLog(maxLines = 50, projectDir) {
   const logPath = resolveLogPath(projectDir);
@@ -107,10 +179,12 @@ export function readRunLog(maxLines = 50, projectDir) {
     const lines = content.split("\n").filter(Boolean);
     const total = lines.length;
     const shown = lines.slice(-maxLines);
+    const status = parseRunStatus(lines);
     return {
       ok: true,
       path: logPath,
       totalLines: total,
+      status,
       lines: shown,
       summary: shown.join("\n")
     };