bingocode 1.1.155 → 1.1.157

package/package.json

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

package/src/manager/CliMenuManager.tsx

@@ -100,6 +100,39 @@ function writeGlobalClaudeConfig(updates: Record<string, unknown>): void {
   fs.renameSync(tmp, configPath);
 }
 
+function readClaudeSettings(): Record<string, unknown> {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const settingsPath = path.join(configDir, 'settings.json');
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf-8');
+    return JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+function writeClaudeSettings(updates: Record<string, unknown>): void {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const settingsPath = path.join(configDir, 'settings.json');
+  const dir = path.dirname(settingsPath);
+  if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); }
+
+  let current: Record<string, unknown> = {};
+  try {
+    if (fs.existsSync(settingsPath)) {
+      const raw = fs.readFileSync(settingsPath, 'utf-8');
+      current = JSON.parse(raw) as Record<string, unknown>;
+    }
+  } catch {}
+
+  const merged = { ...current, ...updates };
+
+  // atomic write via temp + rename
+  const tmp = `${settingsPath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tmp, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+  fs.renameSync(tmp, settingsPath);
+}
+
 /**
  * Determine if in "official" mode (no custom provider active).
  * Logic matches ConversationService.shouldMarkManagedOAuth().
@@ -193,6 +226,9 @@ const i18nMap = {
     autoModeLabel: 'Auto Mode',
     autoModeOn: '已开启',
     autoModeOff: '已关闭',
+    bypassPermsLabel: 'Bypass',
+    bypassPermsOn: '已开启',
+    bypassPermsOff: '已关闭',
   },
   en: {
     menu: {
@@ -229,6 +265,9 @@ const i18nMap = {
     autoModeLabel: 'Auto Mode',
     autoModeOn: 'Enabled',
     autoModeOff: 'Disabled',
+    bypassPermsLabel: 'Bypass',
+    bypassPermsOn: 'Enabled',
+    bypassPermsOff: 'Disabled',
   },
   ja: {
     menu: {
@@ -265,6 +304,9 @@ const i18nMap = {
     autoModeLabel: 'Auto Mode',
     autoModeOn: '有効',
     autoModeOff: '無効',
+    bypassPermsLabel: 'Bypass',
+    bypassPermsOn: '有効',
+    bypassPermsOff: '無効',
   },
 };
 
@@ -384,6 +426,9 @@ export const CliMenuManager: React.FC = () => {
       if (typeof bSettings.autoModeEnabled === 'boolean') {
         setAutoModeEnabled(bSettings.autoModeEnabled);
       }
+      if (typeof bSettings.bypassPermsEnabled === 'boolean') {
+        setBypassPermsEnabled(bSettings.bypassPermsEnabled);
+      }
     } catch {}
   }, []);
 
@@ -442,6 +487,7 @@ export const CliMenuManager: React.FC = () => {
   const [settingsStage, setSettingsStage] = useState<'list' | 'langPicker'>('list');
   const [settingsCursor, setSettingsCursor] = useState(0);
   const [autoModeEnabled, setAutoModeEnabled] = useState(false);
+  const [bypassPermsEnabled, setBypassPermsEnabled] = useState(false);
 
   // Top toolbar state
   const [animEnabled, setAnimEnabled] = useState(true);
@@ -829,7 +875,7 @@ export const CliMenuManager: React.FC = () => {
     if (!showHelp && page === 'settings') {
       if (settingsStage === 'list') {
         // +1 for the fixed Language row prepended before settingData entries
-        const totalRows = 2 + (settingData && typeof settingData === 'object' ? Object.keys(settingData).length : 0);
+        const totalRows = 3 + (settingData && typeof settingData === 'object' ? Object.keys(settingData).length : 0);
         const visible = Math.max(1, MID_H - 2);
         if (key.downArrow || input === 'j') {
           setSettingsCursor(c => Math.min(totalRows - 1, c + 1));
@@ -862,12 +908,27 @@ export const CliMenuManager: React.FC = () => {
               }
               return next;
             });
+          } else if (settingsCursor === 2) {
+            // Row 2: toggle Bypass Permissions
+            setBypassPermsEnabled(prev => {
+              const next = !prev;
+              try {
+                writeBingoSettings({ bypassPermsEnabled: next });
+                const safeSettings = next
+                  ? { permissions: { defaultMode: 'bypassPermissions', skipDangerousModePermissionPrompt: true } }
+                  : { permissions: { defaultMode: 'default' } };
+                writeClaudeSettings(safeSettings);
+              } catch {
+                return prev; // write failed — keep old state
+              }
+              return next;
+            });
           }
         }
       }
       // langPicker stage: ESC handled above; selection via SelectInput onSelect
     }
-  }, [menuItems, page, historyMenuStage, historyList, historyHasMore, navIndex, sessionMessages, settingData, MID_H, MSGS_PAGE_SIZE, showHelp, theme, settingsStage, settingsCursor, autoModeEnabled]);
+  }, [menuItems, page, historyMenuStage, historyList, historyHasMore, navIndex, sessionMessages, settingData, MID_H, MSGS_PAGE_SIZE, showHelp, theme, settingsStage, settingsCursor, autoModeEnabled, bypassPermsEnabled]);
 
   function cleanText(text: string): string {
     return String(text ?? '').replace(/[\n\r]+/g, ' ').replace(/\u001b\[[0-9;]*m/g, '').trim();
@@ -1350,6 +1411,7 @@ export const CliMenuManager: React.FC = () => {
       const fixedRows: SettingRow[] = [
         { key: '__lang', label: tS.langLabel, value: currentLangLabel, interactive: true },
         { key: '__autoMode', label: tS.autoModeLabel, value: autoModeEnabled ? tS.autoModeOn : tS.autoModeOff, interactive: true },
+        { key: '__bypassPerms', label: tS.bypassPermsLabel, value: bypassPermsEnabled ? tS.bypassPermsOn : tS.bypassPermsOff, interactive: true },
       ];
       const dataEntries = settingData && typeof settingData === 'object' ? Object.entries(settingData) : [];
       const dataRows: SettingRow[] = dataEntries.map(([k, v]) => ({

package/src/tools/FileEditTool/utils.ts

@@ -71,11 +71,14 @@ export function stripTrailingWhitespace(str: string): string {
  * @returns The actual string found in the file, or null if not found
  */
 
-/** Normalizes Unicode dashes (em-dash, en-dash, horizontal bar) to standard ASCII dashes.
- * Handles model-output ASCII dashes when file content contains Unicode dash variants.
- * Fixes Edit tool matching failures from encoding discrepancies. */
+/** Normalizes Unicode dashes to ASCII, indent whitespace to spaces.
+ * Fills gaps where models emit ASCII dashes instead of Unicode dashes,
+ * or provide different tab/space indentation than the file has. */
 export function normalizeDashes(str: string): string {
-  return str.replaceAll('—', '-').replaceAll('–', '-').replaceAll('―', '-')
+  return str.replaceAll('\u2014', '-').replaceAll('\u2013', '-').replaceAll('\u2015', '-')
+}
+export function normalizeIndentation(str: string): string {
+  return str.split('\n').map(line => line.trimStart()).join('\n')
 }
 export function findActualString(
   fileContent: string,

package/src/utils/goalEvaluator.ts

@@ -9,21 +9,77 @@ export type GoalEvalResult = {
   gap: string | null
 }
 
+// --- EVAL Block parser for structured evaluation ---
+
+type EvalBlock = {
+  metric: string
+  valueTarget: string
+  passed: boolean
+}
+
 /**
- * Evaluate whether the goal condition has been met based on recent messages.
+ * Parse markdown text for structured > EVAL: lines.
  *
- * Runs as an independent Anthropic client call — completely decoupled from the
- * main query chain. Never pollutes conversation state or tool history.
+ * 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[] = []
+
+  // 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
+}
+
+/** Determine if all metrics pass — enabling early termination. */
+function allMetricsPassing(blocks: EvalBlock[]): boolean {
+  return blocks.length > 0 && blocks.every(b => b.passed)
+}
+
+/** Extract structured EVAL summary from parsed blocks for consumption by evaluator model. */
+function evalSummary(blocks: EvalBlock[]): string {
+  if (blocks.length === 0) return '(no EVAL blocks found)'
+  const passed = blocks.filter(b => b.passed).length
+  return [
+    `Pre-parsed EVAL metrics (${passed}/${blocks.length} passed):`,
+    ...blocks.map(b => `- ${b.metric}: ${b.valueTarget} → ${b.passed ? '✓' : '✗'}`),
+  ].join('\n')
+}
+
+// --- Core evaluator ---
+
+/**
+ * Optimized goal evaluator.
+ *
+ * Strategy:
+ * 1. Regex-parse EVAL blocks from recent assistant text. If all metrics
+ *    pass → short-circuit satisfied without calling evaluator model.
+ * 2. Feed pre-parsed EVAL summary to Haiku-4.5 for fallback evaluation.
  */
 export async function evaluateGoal(
   goalCondition: string,
   messages: MessageType[],
 ): Promise<GoalEvalResult> {
-  const client = new Anthropic({
-    baseURL: process.env.ANTHROPIC_BASE_URL ?? undefined,
-    apiKey: process.env.ANTHROPIC_API_KEY ?? 'dummy',
-  })
-
   const recentAssistantTexts = messages
     .filter(m => m.type === 'assistant' || m.role === 'assistant')
     .slice(-5)
@@ -40,22 +96,39 @@ export async function evaluateGoal(
     .filter(Boolean)
     .join('\n---\n')
 
-  const prompt = `You are a goal completion evaluator. Determine if the goal has been fully achieved.
+  // Phase 1: regex-parse EVAL blocks from recent output (fast, no model call)
+  const evalBlocks = parseEvalBlocks(recentAssistantTexts)
 
-IMPORTANT: The agent may produce EVAL blocks intended for you. Parse them first.
+  // If ALL named metrics pass, the agent itself confirms goal completion.
+  if (evalBlocks.length > 0 && allMetricsPassing(evalBlocks)) {
+    return {
+      satisfied: true,
+      reason: `all ${evalBlocks.length} EVAL metrics satisfied`,
+      gap: null,
+    }
+  }
 
-Goal: "${goalCondition}"
+  // Phase 2: Fallback to Haiku evaluator with pre-parsed summary
+  const evalInput = [
+    evalSummary(evalBlocks),
+    '(note: EVAL blocks already pre-parsed above — use to guide your evaluation)',
+    '',
+    recentAssistantTexts.slice(-4000), // trim long messages to fit context
+  ].join('\n')
 
-Recent assistant output:
-${recentAssistantTexts || '(none yet)'}
+  const client = new Anthropic({
+    baseURL: process.env.ANTHROPIC_BASE_URL ?? undefined,
+    apiKey: process.env.ANTHROPIC_API_KEY ?? 'dummy',
+  })
 
-Evaluate:
-1. Did the agent produce a final EVAL block? If so, use those values directly.
-2. If no EVAL blocks found, infer based on any explicit declarations (e.g. "✓", "100%", "fixed", "complete").
-3. Output ONLY valid JSON — no explanation or markdown.
+  const prompt = `Goal condition to evaluate: "${goalCondition}"
 
-Respond in:
-{"satisfied": true|false, "reason": "<one sentence>", "gap": "<missing item or null>"}`
+The assistant's recent output is below. Based ONLY on it, determine if the goal is 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 {
@@ -66,6 +139,7 @@ Respond in:
     })
     text = response.content.find((b: any) => b.type === 'text')?.text || ''
   } catch (e) {
+    // Short-circuit on API error — parse what we can
     return {
       satisfied: false,
       reason: 'Evaluator API error',
@@ -73,24 +147,62 @@ Respond in:
     }
   }
 
-  try {
-    // Strip markdown code fences and find JSON object bounds
-    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,
+  }
 }