bingocode 1.1.156 → 1.1.157

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.156",
+  "version": "1.1.157",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/utils/goalEvaluator.ts

@@ -18,18 +18,34 @@ type EvalBlock = {
 }
 
 /**
- * Parse markdown text for structured statement > EVAL: lines.
+ * Parse markdown text for structured > EVAL: lines.
  *
- * Expected actor format:
+ * Accepted actor formats:
  *   > EVAL: <metric>: <value> / <target> → ✓ or ✗
+ *   > EVAL: <metric>: <value> / <target> -> PASS
+ *   > EVAL: <metric>: <value> / <target> => true
+ *
+ * Supports ASCII and Unicode arrow/check/cross variants for maximum compatibility.
  */
 function parseEvalBlocks(text: string): EvalBlock[] {
   const blocks: EvalBlock[] = []
-  const regex = />\s*EVAL:\s*(.+?):\s*(.+?)\s*→\s*(✓|✗)/g
-  let match
-  while ((match = regex.exec(text)) !== null) {
-    const [, metric, valueTarget, result] = match
-    const passed = result === '✓' || result === '✔'
+
+  // Build one combined pattern: capture metric + valuetarget + pass/fail signal.
+  // Arrow variants: → (U+2192), -> (ASCII), => (ASCII)
+  // Pass variants: ✓ (U+2713), ✔ (U+2714), PASS (case-insensitive), Y, true, yes, 1
+  // Fail variants: ✗ (U+2717), ✘ (U+2718), FAIL (case-insensitive), N, false, no, 0
+  const arrow = /(?:→|->|=>)/g.source
+  const pass = /(?:✓|✔|PASS|pass|Y\b|true|yes|1)/g.source
+  const fail = /(?:✗|✘|FAIL|fail|N\b|false|no|0)/g.source
+  const full = new RegExp(
+    `>\\s*EVAL:\\s*(.+?):\\s*(.+?)\\s*(?:${arrow}|)\\s*(${pass}|${fail})`,
+    'g',
+  )
+
+  let match: RegExpExecArray | null
+  while ((match = full.exec(text)) !== null) {
+    const [, metric, valueTarget, signal] = match
+    const passed = /^(✓|✔|PASS|pass|Y\b|true|yes|1)$/.test(signal.trim())
     blocks.push({ metric: metric.trim(), valueTarget: valueTarget.trim(), passed })
   }
   return blocks
@@ -105,12 +121,14 @@ export async function evaluateGoal(
     apiKey: process.env.ANTHROPIC_API_KEY ?? 'dummy',
   })
 
-  const prompt = `You are a goal completion evaluator. Determine if ${goalCondition} is fulfilled.
+  const prompt = `Goal condition to evaluate: "${goalCondition}"
 
-${evalInput.slice(0, 6000)}
+The assistant's recent output is below. Based ONLY on it, determine if the goal is satisfied.
 
-Evaluate and respond ONLY in valid JSON:
-{"satisfied": true|false, "reason": "<one sentence>", "gap": "<specific missing item, or null if satisfied>"}`
+RESPOND WITH ONLY VALID JSON — no markdown, no explanation:
+{"satisfied": true|false, "reason": "<one sentence why>", "gap": "<what's still missing, or null if satisfied>"}
+
+${evalInput.slice(0, 5000)}`
 
   let text = ''
   try {
@@ -129,24 +147,62 @@ Evaluate and respond ONLY in valid JSON:
     }
   }
 
-  // Phase 3: Parse evaluator output back to JSON
-  try {
-    let cleaned = text
-      .replace(/```(?:json)?\s*/gi, '')
-      .replace(/```/g, '')
-      .trim()
-    const start = cleaned.indexOf('{')
-    const end = cleaned.lastIndexOf('}')
-    if (start === -1 || end === -1 || end <= start) {
-      throw new Error('No JSON object found')
-    }
-    cleaned = cleaned.slice(start, end + 1)
-    return JSON.parse(cleaned) as GoalEvalResult
-  } catch (e) {
-    return {
-      satisfied: false,
-      reason: 'Evaluator parse error',
-      gap: `${e instanceof Error && e.message !== 'No JSON object found' ? e.message : 'raw output'}: ${text.slice(0, 200)}`,
+  // Phase 3: Parse evaluator output back to JSON.
+  // Try strict JSON first, then fuzzy extraction, then interpret heuristics.
+  const parseError = (detail: string): GoalEvalResult => ({
+    satisfied: false,
+    reason: 'Evaluator parse error',
+    gap: `Failed to parse evaluator output. Detail: ${detail}. First 120 chars of raw response: ${text.slice(0, 120)}`,
+  })
+
+  const tryJsonParse = (raw: string): { ok: true; value: GoalEvalResult } | { ok: false } => {
+    try {
+      let cleaned = raw
+        .replace(/```(?:json)?\s*/gi, '')
+        .replace(/```/g, '')
+        .trim()
+      const start = cleaned.indexOf('{')
+      const end = cleaned.lastIndexOf('}')
+      if (start === -1 || end === -1 || end <= start) return { ok: false }
+      cleaned = cleaned.slice(start, end + 1)
+      const parsed = JSON.parse(cleaned)
+      if (typeof parsed.satisfied === 'boolean') {
+        return {
+          ok: true,
+          value: {
+            satisfied: parsed.satisfied,
+            reason: parsed.reason || '',
+            gap: parsed.gap || null,
+          },
+        }
+      }
+      return { ok: false }
+    } catch {
+      return { ok: false }
     }
   }
+
+  // Attempt 1 — strict JSON parse of the raw text
+  const result = tryJsonParse(text)
+  if (result.ok) return result.value
+
+  // Attempt 2 — heuristic extraction from text response
+  const lower = text.toLowerCase()
+  const looksSatisfied =
+    lower.includes('"satisfied": true') ||
+    (lower.includes('satisfied') && lower.includes('true')) ||
+    /goal\s+is\s+(?:met|satisfied|achieved)/.test(lower) ||
+    /condition\s+is\s+(?:met|satisfied|fulfilled)/.test(lower)
+
+  const extractString = (field: string): string => {
+    const regex = new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, 'i')
+    const match = text.match(regex)
+    return match ? match[1] : 'unknown'
+  }
+
+  return {
+    satisfied: looksSatisfied,
+    reason: extractString('reason') || (looksSatisfied ? 'condition matched' : 'condition not met'),
+    gap: extractString('gap') || null,
+  }
 }