iterate-plugin 2.7.1 → 2.7.3

package/lib/parse.js

@@ -160,6 +160,139 @@ export function scanSessionForReport(session) {
   return null
 }
 
+// ─── Run-summary / meta-review verdict detection ─────────────────────────────
+
+/**
+ * Check whether `obj` is an iterate dry-run run-summary object (the structured
+ * object returned by the workflow at the end of a dry-run). It wraps the
+ * ReviewReport and carries the meta-review verdict:
+ *   { mode, goal, rounds, converged, ..., report, metaReview, finalReport }
+ * The discriminator is `finalReport.verdict`, which only the meta-review
+ * closing step produces ("approved" | "needs_revision"). This shape is distinct
+ * from a ReviewReport (which has `convergence`/`findings`/`rounds`), so it never
+ * collides with `isReviewReport`.
+ *
+ * @param {unknown} obj
+ * @returns {obj is Record<string, unknown>}
+ */
+export function isRunSummary(obj) {
+  if (!obj || typeof obj !== 'object') return false
+  const o = /** @type {Record<string, unknown>} */ (obj)
+  const final = o.finalReport
+  return !!final &&
+    typeof final === 'object' &&
+    (final.verdict === 'approved' || final.verdict === 'needs_revision')
+}
+
+/**
+ * Deep-scan an object tree for the first iterate run-summary (same traversal
+ * semantics as `findReportInObject`, with circular-reference + depth guards).
+ *
+ * @param {unknown} obj
+ * @param {Set<unknown>} [seen]
+ * @param {number} [maxDepth=20]
+ * @returns {Record<string, unknown> | null}
+ */
+export function findRunSummaryInObject(obj, seen, maxDepth = 20) {
+  if (maxDepth <= 0) return null
+  if (!obj || typeof obj !== 'object') return null
+
+  const s = seen || new Set()
+  if (s.has(obj)) return null
+  s.add(obj)
+
+  if (isRunSummary(obj)) return /** @type {Record<string, unknown>} */ (obj)
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const found = findRunSummaryInObject(item, s, maxDepth - 1)
+      if (found) return found
+    }
+    return null
+  }
+
+  const o = /** @type {Record<string, unknown>} */ (obj)
+  for (const key of Object.keys(o)) {
+    const val = o[key]
+    if (val && typeof val === 'object') {
+      const found = findRunSummaryInObject(val, s, maxDepth - 1)
+      if (found) return found
+    }
+  }
+
+  return null
+}
+
+/**
+ * Scan a session snapshot (or any object) for the latest iterate dry-run
+ * run-summary that exposes a meta-review verdict. Prefers the most recent.
+ *
+ * @param {unknown} session
+ * @returns {Record<string, unknown> | null}
+ */
+export function scanSessionForRunSummary(session) {
+  if (!session || typeof session !== 'object') return null
+
+  const direct = findRunSummaryInObject(session)
+  if (direct) return direct
+
+  const s = /** @type {Record<string, unknown>} */ (session)
+
+  // Common pattern: session.toolCalls[].result contains a run summary.
+  if (Array.isArray(s.toolCalls)) {
+    const calls = /** @type {Array<Record<string, unknown>>} */ (s.toolCalls)
+    for (let i = calls.length - 1; i >= 0; i--) {
+      const call = calls[i]
+      if (!call) continue
+      if (call.tool === 'workflow' || String(call.tool ?? '').endsWith('workflow')) {
+        const found = findRunSummaryInObject(call.result, undefined, 24)
+        if (found) return found
+      }
+    }
+  }
+
+  // Common pattern: assistant message content holding the workflow return.
+  if (Array.isArray(s.messages)) {
+    const msgs = /** @type {Array<Record<string, unknown>>} */ (s.messages)
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const msg = msgs[i]
+      if (!msg) continue
+      const found = findRunSummaryInObject(msg.content)
+      if (found) return found
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extract a compact, UI-friendly verdict from a run-summary object.
+ * Returns null when the object is not a valid run-summary.
+ *
+ * @param {Record<string, unknown> | null | undefined} runSummary
+ * @returns {{ verdict: 'approved' | 'needs_revision', reportIssues: number, checksRun: number, converged: boolean, totalRounds: number, totalFindings: number } | null}
+ */
+export function extractVerdict(runSummary) {
+  if (!isRunSummary(runSummary)) return null
+  const o = /** @type {Record<string, unknown>} */ (runSummary)
+  const final = /** @type {Record<string, unknown>} */ (o.finalReport)
+  const meta = final.metaReview && typeof final.metaReview === 'object'
+    ? /** @type {Record<string, unknown>} */ (final.metaReview)
+    : {}
+  const issues = Array.isArray(meta.issues) ? meta.issues : []
+  // `totalRounds` may be a bare number (dry-run returns `rounds`) or a count.
+  const roundsVal = o.rounds
+  const totalRounds = typeof roundsVal === 'number' ? roundsVal : (Array.isArray(roundsVal) ? roundsVal.length : 0)
+  return {
+    verdict: final.verdict === 'needs_revision' ? 'needs_revision' : 'approved',
+    reportIssues: issues.length,
+    checksRun: typeof meta.checksRun === 'number' ? meta.checksRun : 0,
+    converged: o.converged === true,
+    totalRounds,
+    totalFindings: typeof o.totalFindings === 'number' ? o.totalFindings : 0,
+  }
+}
+
 // ─── Normalization ───────────────────────────────────────────────────────────
 
 /**
@@ -193,7 +326,9 @@ export function normalizeReport(report) {
   }
 
   // Compute summary if missing. Always build a NEW object so the input's
-  // summary (or any other field) is never mutated.
+  // summary (or any other field) is never mutated. `fixedCount` (normal mode
+  // only) is carried through so the dashboard fix-count metric survives
+  // normalization.
   let summary = report.summary
   if (!summary || typeof summary !== 'object') {
     summary = computeSummaryFromFindings(findings)
@@ -209,6 +344,7 @@ export function normalizeReport(report) {
       byDimension: s.byDimension && typeof s.byDimension === 'object'
         ? s.byDimension
         : computed.byDimension,
+      ...(typeof s.fixedCount === 'number' ? { fixedCount: s.fixedCount } : {}),
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-plugin",
-  "version": "2.7.1",
+  "version": "2.7.3",
   "description": "dsh plugin that turns the iterate skill into an autonomous closed-loop harness: plan -> parallel review xN -> atomic fixes -> validate -> loop -> auto-stop, plus a dry-run pure-review mode with multi-round convergence and a meta-review that audits the report and emits a final review report.",
   "type": "module",
   "license": "MIT",
@@ -53,8 +53,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "npm run build",
+    "build:client": "node scripts/build-client.mjs",
+    "prepublishOnly": "npm run build && npm run build:client",
     "typecheck": "tsc --noEmit",
+    "typecheck:client": "tsc --noEmit -p tsconfig.client.json",
     "test": "tsx --test test/*.test.ts",
     "test:validate": "tsx --test test/validate.test.ts"
   },
@@ -67,6 +69,8 @@
     "@deepseek-ai/dsh-session": "0.1.0-rc.6",
     "@types/js-yaml": "4.0.9",
     "@types/node": "22.15.0",
+    "@types/react": "19.2.2",
+    "esbuild": "0.25.12",
     "tsx": "4.20.3",
     "typescript": "5.9.3"
   },