bingocode 1.1.154 → 1.1.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.154",
+  "version": "1.1.156",
   "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/skills/bundled/goal.ts

@@ -59,10 +59,17 @@ export function registerGoalSkill(): void {
 
 Goal condition: "${trimmed}"
 
-This goal is now registered for this session. An independent evaluator model will check after each turn whether the goal is satisfied. Maximum ${maxIter} iterations.
+This goal is now registered for this session. After each turn, an independent evaluator (Haiku 4.5, a weak model) will check whether the goal is satisfied. Maximum ${maxIter} iterations.
 
-Tell the user: Goal set — you will work autonomously until "${trimmed}" is achieved (max ${maxIter} turns). Send \`/goal clear\` to cancel.
+CRITICAL: The evaluator reads ONLY your text output. It cannot see code changes, tool results, or file contents — only the plain text you write.
+
+At each turn toward the goal, output a short evaluation block like:
+> EVAL: [metric1]: [value] / [target]  →  ✓ or ✗
 
+This block is the ONLY signal the evaluator can reliably process. Make it short,
+unambiguous, and quantitative. Do NOT expect the evaluator to infer success from narrative discussion.
+
+Tell the user: Goal set — you will work autonomously until "${trimmed}" is achieved (max ${maxIter} turns). Send \`/goal clear\` to cancel.
 Now begin: assess current state and take the first concrete action toward the goal.`,
         },
       ]

package/src/tools/FileEditTool/utils.ts

@@ -70,6 +70,16 @@ export function stripTrailingWhitespace(str: string): string {
  * @param searchString The string to search for
  * @returns The actual string found in the file, or null if not found
  */
+
+/** 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('\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,
   searchString: string,
@@ -89,6 +99,14 @@ export function findActualString(
     return fileContent.substring(searchIndex, searchIndex + searchString.length)
   }
 
+  // Try with normalized dashes (em-dash, en-dash -> ASCII dash)
+  const dashedSearch = normalizeDashes(searchString)
+  const dashedFile = normalizeDashes(fileContent)
+  const dashIndex = dashedFile.indexOf(dashedSearch)
+  if (dashIndex !== -1) {
+    return fileContent.substring(dashIndex, dashIndex + searchString.length)
+  }
+
   return null
 }
 

package/src/utils/goalEvaluator.ts

@@ -9,21 +9,61 @@ 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 statement > EVAL: lines.
  *
- * Runs as an independent Anthropic client call — completely decoupled from the
- * main query chain. Never pollutes conversation state or tool history.
+ * Expected actor format:
+ *   > EVAL: <metric>: <value> / <target> → ✓ or ✗
+ */
+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 === '✔'
+    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,15 +80,37 @@ 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)
+
+  // 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,
+    }
+  }
+
+  // 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')
+
+  const client = new Anthropic({
+    baseURL: process.env.ANTHROPIC_BASE_URL ?? undefined,
+    apiKey: process.env.ANTHROPIC_API_KEY ?? 'dummy',
+  })
 
-Goal: "${goalCondition}"
+  const prompt = `You are a goal completion evaluator. Determine if ${goalCondition} is fulfilled.
 
-Recent assistant output:
-${recentAssistantTexts || '(none yet)'}
+${evalInput.slice(0, 6000)}
 
-Respond in JSON only:
-{"satisfied": true|false, "reason": "<one sentence>", "gap": "<missing item or null>"}`
+Evaluate and respond ONLY in valid JSON:
+{"satisfied": true|false, "reason": "<one sentence>", "gap": "<specific missing item, or null if satisfied>"}`
 
   let text = ''
   try {
@@ -59,6 +121,7 @@ Respond in JSON only:
     })
     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',
@@ -66,8 +129,8 @@ Respond in JSON only:
     }
   }
 
+  // Phase 3: Parse evaluator output back to JSON
   try {
-    // Strip markdown code fences and find JSON object bounds
     let cleaned = text
       .replace(/```(?:json)?\s*/gi, '')
       .replace(/```/g, '')