@jsonstudio/rcc 0.89.935 → 0.89.1083

package/scripts/analyze-apply-patch-exec-failures.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const HOME = os.homedir();
+const RESPONSES_DIR = path.join(HOME, '.routecodex', 'codex-samples', 'openai-responses');
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function* walkJsonFiles(root) {
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
+        yield full;
+      }
+    }
+  }
+}
+
+function extractApplyPatchResults(doc) {
+  const results = [];
+  function visit(node) {
+    if (!node) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (typeof node !== 'object') return;
+    const any = node;
+
+    if (any.name === 'apply_patch' && any.response && typeof any.response === 'object') {
+      const resp = any.response;
+      let text = '';
+      if (typeof resp.result === 'string') text = resp.result;
+      else if (typeof resp.output === 'string') text = resp.output;
+      results.push(text);
+    }
+
+    if (any.type === 'tool_result' && any.name === 'apply_patch') {
+      let text = '';
+      if (typeof any.result === 'string') text = any.result;
+      else if (typeof any.output === 'string') text = any.output;
+      else if (Array.isArray(any.output)) {
+        text = any.output
+          .map((entry) => {
+            if (typeof entry === 'string') return entry;
+            if (entry && typeof entry === 'object') {
+              if (typeof entry.text === 'string') return entry.text;
+              if (typeof entry.content === 'string') return entry.content;
+            }
+            return '';
+          })
+          .filter(Boolean)
+          .join('\n');
+      }
+      results.push(text);
+    }
+
+    for (const value of Object.values(any)) visit(value);
+  }
+  visit(doc);
+  return results;
+}
+
+function isExecutionFailure(text) {
+  if (!text || typeof text !== 'string') return false;
+  const lower = text.toLowerCase();
+  if (text.includes('apply_patch verification failed')) return false;
+  if (!lower.includes('failed') && !lower.includes('error') && !lower.includes('exception')) return false;
+  return true;
+}
+
+function normalizeKey(text) {
+  if (!text) return '<empty>'; 
+  const firstLine = text.split('\n')[0].trim();
+  return firstLine.length > 200 ? firstLine.slice(0, 200) : firstLine;
+}
+
+async function main() {
+  if (!(await fileExists(RESPONSES_DIR))) {
+    console.error('[analyze-apply-patch-exec-failures] no openai-responses dir at', RESPONSES_DIR);
+    process.exit(0);
+  }
+
+  const byKey = new Map();
+  let total = 0;
+
+  for await (const filePath of walkJsonFiles(RESPONSES_DIR)) {
+    let doc;
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      doc = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const results = extractApplyPatchResults(doc);
+    if (!results.length) continue;
+    for (const text of results) {
+      if (!isExecutionFailure(text)) continue;
+      total += 1;
+      const key = normalizeKey(text);
+      const current = byKey.get(key) || { count: 0, examples: [] };
+      current.count += 1;
+      if (current.examples.length < 3) {
+        current.examples.push(path.basename(filePath));
+      }
+      byKey.set(key, current);
+    }
+  }
+
+  console.log(`[analyze-apply-patch-exec-failures] total execution-like failures: ${total}`);
+
+  const sorted = Array.from(byKey.entries()).sort((a, b) => b[1].count - a[1].count);
+  const top = sorted.slice(0, 30);
+
+  for (const [key, value] of top) {
+    console.log('\n--- pattern ---');
+    console.log(`count=${value.count}`);
+    console.log(`firstLine=${JSON.stringify(key)}`);
+    if (value.examples.length) {
+      console.log('examples:');
+      for (const ex of value.examples) {
+        console.log(`  - ${ex}`);
+      }
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('[analyze-apply-patch-exec-failures] failed:', err);
+  process.exit(1);
+});
+

package/scripts/analyze-apply-patch-samples.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * Scan ~/.routecodex/codex-samples for apply_patch usage and
+ * count successful vs failed invocations.
+ *
+ * We look for apply_patch tool *results* in any JSON snapshot:
+ * - Gemini-style functionResponse.response.result
+ * - OpenAI-style tool_result with name === "apply_patch"
+ *
+ * Classification:
+ * - validationFailure: message contains "apply_patch verification failed"
+ * - executionFailure: message contains generic "failed"/"error"/"exception"
+ *   but not the verification pattern
+ * - success: there is a result string and it doesn't look like a failure
+ * - unknown: no textual result payload
+ *
+ * Note: counts are per snapshot occurrence, not de-duplicated by requestId.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const HOME = os.homedir();
+const ROOT = path.join(HOME, '.routecodex', 'codex-samples');
+const ENTRIES = ['openai-responses', 'openai-chat', 'anthropic-messages'];
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function* walkJsonFiles(root) {
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
+        yield full;
+      }
+    }
+  }
+}
+
+function extractApplyPatchResults(doc) {
+  const results = [];
+
+  function visit(node) {
+    if (!node) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (typeof node !== 'object') {
+      return;
+    }
+    const any = node;
+
+    // Gemini-style: functionResponse { name: "apply_patch", response: { result: "..." } }
+    if (any.name === 'apply_patch' && any.response && typeof any.response === 'object') {
+      const resp = any.response;
+      let text = '';
+      if (typeof resp.result === 'string') {
+        text = resp.result;
+      } else if (typeof resp.output === 'string') {
+        text = resp.output;
+      }
+      results.push({ kind: 'result', text });
+    }
+
+    // OpenAI-style tool_result: { type: "tool_result", name: "apply_patch", result/output: ... }
+    if (any.type === 'tool_result' && any.name === 'apply_patch') {
+      let text = '';
+      if (typeof any.result === 'string') {
+        text = any.result;
+      } else if (typeof any.output === 'string') {
+        text = any.output;
+      } else if (Array.isArray(any.output)) {
+        text = any.output
+          .map((entry) => {
+            if (typeof entry === 'string') return entry;
+            if (entry && typeof entry === 'object') {
+              if (typeof entry.text === 'string') return entry.text;
+              if (typeof entry.content === 'string') return entry.content;
+            }
+            return '';
+          })
+          .filter(Boolean)
+          .join('\n');
+      }
+      results.push({ kind: 'result', text });
+    }
+
+    // Function-call style apply_patch invocation
+    if (
+      (any.type === 'function_call' || any.type === 'functionCall') &&
+      any.name === 'apply_patch'
+    ) {
+      results.push({ kind: 'call', text: '' });
+    }
+
+    // Provider tool_calls: { function: { name: "apply_patch", ... } }
+    if (any.function && typeof any.function === 'object' && any.function.name === 'apply_patch') {
+      results.push({ kind: 'call', text: '' });
+    }
+
+    for (const value of Object.values(any)) {
+      visit(value);
+    }
+  }
+
+  visit(doc);
+  return results;
+}
+
+function classifyResultText(text) {
+  if (!text || typeof text !== 'string') {
+    return 'unknown';
+  }
+  const lower = text.toLowerCase();
+  if (text.includes('apply_patch verification failed')) {
+    return 'validationFailure';
+  }
+  if (lower.includes('verification failed')) {
+    return 'validationFailure';
+  }
+  if (lower.includes('failed') || lower.includes('error') || lower.includes('exception')) {
+    return 'executionFailure';
+  }
+  return 'success';
+}
+
+async function main() {
+  if (!(await fileExists(ROOT))) {
+    console.error('[analyze-apply-patch-samples] codex-samples not found at', ROOT);
+    process.exit(0);
+  }
+
+  const totals = {
+    filesScanned: 0,
+    calls: 0,
+    results: 0,
+    success: 0,
+    validationFailure: 0,
+    executionFailure: 0,
+    unknown: 0
+  };
+
+  const byEntry = {};
+
+  for (const entry of ENTRIES) {
+    const entryDir = path.join(ROOT, entry);
+    if (!(await fileExists(entryDir))) {
+      continue;
+    }
+    const stats = {
+      filesScanned: 0,
+      calls: 0,
+      results: 0,
+      success: 0,
+      validationFailure: 0,
+      executionFailure: 0,
+      unknown: 0
+    };
+
+    for await (const filePath of walkJsonFiles(entryDir)) {
+      stats.filesScanned += 1;
+      totals.filesScanned += 1;
+      let doc;
+      try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        doc = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const results = extractApplyPatchResults(doc);
+      if (!results.length) continue;
+
+      for (const item of results) {
+        if (item.kind === 'call') {
+          stats.calls += 1;
+          totals.calls += 1;
+          continue;
+        }
+        if (item.kind === 'result') {
+          stats.results += 1;
+          totals.results += 1;
+          const bucket = classifyResultText(item.text);
+          if (bucket === 'success') {
+            stats.success += 1;
+            totals.success += 1;
+          } else if (bucket === 'validationFailure') {
+            stats.validationFailure += 1;
+            totals.validationFailure += 1;
+          } else if (bucket === 'executionFailure') {
+            stats.executionFailure += 1;
+            totals.executionFailure += 1;
+          } else {
+            stats.unknown += 1;
+            totals.unknown += 1;
+          }
+        }
+      }
+    }
+
+    byEntry[entry] = stats;
+  }
+
+  console.log('[analyze-apply-patch-samples] summary (per snapshot, not de-duplicated by reqId):');
+  console.log(
+    `TOTAL files=${totals.filesScanned}, calls=${totals.calls}, results=${totals.results},` +
+      ` success=${totals.success}, validationFailure=${totals.validationFailure},` +
+      ` executionFailure=${totals.executionFailure}, unknown=${totals.unknown}`
+  );
+  for (const [entry, s] of Object.entries(byEntry)) {
+    console.log(
+      `${entry}: files=${s.filesScanned}, calls=${s.calls}, results=${s.results},` +
+        ` success=${s.success}, validationFailure=${s.validationFailure},` +
+        ` executionFailure=${s.executionFailure}, unknown=${s.unknown}`
+    );
+  }
+}
+
+main().catch((error) => {
+  console.error('[analyze-apply-patch-samples] failed:', error);
+  process.exit(1);
+});
+

package/scripts/analyze-codex-error-failures.mjs

@@ -37,11 +37,25 @@ async function fileExists(p) {
   }
 }
 
-async function listJsonFiles(root) {
-  const entries = await fs.readdir(root);
-  return entries
-    .filter((name) => name.toLowerCase().endsWith('.json'))
-    .map((name) => path.join(root, name));
+async function* walkJsonFiles(root) {
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
+        yield full;
+      }
+    }
+  }
 }
 
 async function analyzeFile(filePath) {
@@ -61,20 +75,13 @@ async function main() {
     process.exit(0);
   }
 
-  const files = await listJsonFiles(RESPONSES_DIR);
-  if (!files.length) {
-    console.log('[analyze-codex-error-failures] no JSON files under', RESPONSES_DIR);
-    process.exit(0);
-  }
-
-  console.log(`[analyze-codex-error-failures] scanning ${files.length} file(s) under ${RESPONSES_DIR}`);
-
   const summary = new Map();
   for (const p of PATTERNS) {
     summary.set(p, { count: 0, files: [] });
   }
 
-  for (const file of files) {
+  let scanned = 0;
+  for await (const file of walkJsonFiles(RESPONSES_DIR)) {
     let res;
     try {
       res = await analyzeFile(file);
@@ -90,8 +97,11 @@ async function main() {
         entry.files.push(path.basename(file));
       }
     }
+    scanned += 1;
   }
 
+  console.log(`[analyze-codex-error-failures] scanned ${scanned} file(s) under ${RESPONSES_DIR}`);
+
   for (const key of PATTERNS) {
     const { count, files } = summary.get(key);
     console.log(`\n=== Pattern: "${key}" ===`);

package/scripts/classify-codex-samples.mjs

@@ -30,7 +30,6 @@ const PROVIDER_KEYS = {
 const TOOL_TYPES = {
   'apply_patch': 'apply_patch',
   'shell': 'shell_command',
-  'toon': 'toon_tool',
   'submit_tool_outputs': 'tool_loop',
   'list_files': 'file_operation',
   'write_file': 'file_operation',
@@ -46,7 +45,6 @@ class SampleClassifier {
       byProvider: {},
       byToolType: {},
       withToolCalls: 0,
-      withToon: 0,
       errors: 0
     };
   }
@@ -68,9 +66,6 @@ class SampleClassifier {
   identifyToolType(toolCall) {
     const funcName = toolCall.function?.name || '';
     
-    // 检查 TOON 格式
-    if (this.isToonTool(toolCall)) return 'toon_tool';
-    
     // 检查已知工具名称
     for (const [pattern, type] of Object.entries(TOOL_TYPES)) {
       if (funcName.toLowerCase().includes(pattern)) return type;
@@ -84,19 +79,6 @@ class SampleClassifier {
     return 'unknown_tool';
   }
 
-  // 检查是否为 TOON 工具
-  isToonTool(toolCall) {
-    const args = toolCall.function?.arguments;
-    if (!args) return false;
-    
-    try {
-      const parsed = JSON.parse(args);
-      return parsed && typeof parsed.toon === 'string';
-    } catch {
-      return false;
-    }
-  }
-
   // 分析单个样本
   async analyzeSample(filePath) {
     try {
@@ -107,7 +89,6 @@ class SampleClassifier {
       const sampleId = basename(dirname(filePath)) + '/' + basename(filePath, '.json');
       
       let toolCalls = [];
-      let hasToon = false;
       
       // 提取 tool_calls
       if (data.tool_calls) {
@@ -128,8 +109,6 @@ class SampleClassifier {
         const toolType = this.identifyToolType(toolCall);
         toolTypes.push(toolType);
         
-        if (toolType === 'toon_tool') hasToon = true;
-        
         // 更新统计
         this.stats.byToolType[toolType] = (this.stats.byToolType[toolType] || 0) + 1;
       }
@@ -140,7 +119,6 @@ class SampleClassifier {
         filePath,
         hasToolCalls: toolCalls.length > 0,
         toolTypes,
-        hasToon,
         toolCallCount: toolCalls.length
       };
       
@@ -150,7 +128,6 @@ class SampleClassifier {
       this.stats.total++;
       this.stats.byProvider[providerKey] = (this.stats.byProvider[providerKey] || 0) + 1;
       if (toolCalls.length > 0) this.stats.withToolCalls++;
-      if (hasToon) this.stats.withToon++;
       
     } catch (error) {
       console.error(`Error analyzing ${filePath}:`, error.message);
@@ -196,7 +173,6 @@ class SampleClassifier {
     
     console.log(`总样本数: ${this.stats.total}`);
     console.log(`包含工具调用: ${this.stats.withToolCalls}`);
-    console.log(`包含 TOON: ${this.stats.withToon}`);
     console.log(`错误数: ${this.stats.errors}`);
     
     console.log('\n按 Provider 分布:');
@@ -224,21 +200,10 @@ class SampleClassifier {
     console.log('==================');
     
     const hasApplyPatch = this.stats.byToolType['apply_patch'] > 0;
-    const hasToon = this.stats.byToolType['toon_tool'] > 0;
     const hasShell = this.stats.byToolType['shell_command'] > 0;
     
     if (!hasApplyPatch) console.log('  - 缺少 apply_patch 样本');
-    if (!hasToon) console.log('  - 缺少 TOON 工具样本');
     if (!hasShell) console.log('  - 缺少 shell command 样本');
-    
-    // TOON 样本详情
-    if (this.stats.withToon > 0) {
-      console.log('\n🔧 TOON 工具样本:');
-      const toonSamples = this.samples.filter(s => s.hasToon);
-      for (const sample of toonSamples) {
-        console.log(`  - ${sample.provider}: ${sample.id}`);
-      }
-    }
   }
 }
 

package/scripts/copy-modules-config.mjs

@@ -6,6 +6,8 @@ async function copyModulesConfig() {
   const root = process.cwd();
   const srcModulesConfig = path.join(root, 'config', 'modules.json');
   const distModulesConfig = path.join(root, 'dist', 'config', 'modules.json');
+  const srcDaemonAdminUi = path.join(root, 'docs', 'daemon-admin-ui.html');
+  const distDaemonAdminUi = path.join(root, 'dist', 'docs', 'daemon-admin-ui.html');
 
   try {
     // 确保源文件存在
@@ -18,6 +20,20 @@ async function copyModulesConfig() {
     await fs.copyFile(srcModulesConfig, distModulesConfig);
 
     console.log('[copy-modules-config] copied modules.json to dist/config/modules.json');
+
+    try {
+      await fs.access(srcDaemonAdminUi);
+      await fs.mkdir(path.dirname(distDaemonAdminUi), { recursive: true });
+      await fs.copyFile(srcDaemonAdminUi, distDaemonAdminUi);
+      console.log('[copy-modules-config] copied daemon-admin-ui.html to dist/docs/daemon-admin-ui.html');
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        console.warn('[copy-modules-config] docs/daemon-admin-ui.html not found, skipping');
+      } else {
+        console.error('[copy-modules-config] failed to copy daemon admin ui:', error.message);
+        process.exit(1);
+      }
+    }
   } catch (error) {
     if (error.code === 'ENOENT') {
       console.warn('[copy-modules-config] source modules.json not found, skipping');
@@ -28,4 +44,4 @@ async function copyModulesConfig() {
   }
 }
 
-copyModulesConfig();
+copyModulesConfig();

package/scripts/generate-snapshot-data.mjs

@@ -148,21 +148,26 @@ class SnapshotDataGenerator {
     
     try {
       await fs.mkdir(outputDir, { recursive: true });
-      const files = await fs.readdir(responsesDir);
-      
-      const groups = this.groupFilesByRequestId(files);
       let count = 0;
-      
-      for (const [requestId, groupFiles] of Object.entries(groups)) {
+
+      const entries = await fs.readdir(responsesDir, { withFileTypes: true });
+
+      // New layout: openai-responses/<requestId>/*.json
+      for (const entry of entries) {
         if (count >= MAX_SAMPLES) break;
-        
+        if (!entry.isDirectory()) continue;
+        const requestId = entry.name;
+        if (!requestId.startsWith('req_') && !requestId.includes('responses')) continue;
+
+        const subdirPath = path.join(responsesDir, requestId);
+        const files = (await fs.readdir(subdirPath)).filter((f) => f.endsWith('.json'));
         const snapshot = await this.buildSnapshotFromFiles(
-          requestId, 
-          'openai-responses', 
-          groupFiles, 
-          responsesDir
+          requestId,
+          'openai-responses',
+          files,
+          subdirPath
         );
-        
+
         if (snapshot) {
           const outputPath = path.join(outputDir, `${requestId}.json`);
           await fs.writeFile(outputPath, JSON.stringify(snapshot, null, 2));
@@ -171,6 +176,31 @@ class SnapshotDataGenerator {
           this.samplesGenerated++;
         }
       }
+
+      // Legacy layout: openai-responses/*.json
+      if (count < MAX_SAMPLES) {
+        const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+        const groups = this.groupFilesByRequestId(files);
+      
+        for (const [requestId, groupFiles] of Object.entries(groups)) {
+          if (count >= MAX_SAMPLES) break;
+
+          const snapshot = await this.buildSnapshotFromFiles(
+            requestId,
+            'openai-responses',
+            groupFiles,
+            responsesDir
+          );
+
+          if (snapshot) {
+            const outputPath = path.join(outputDir, `${requestId}.json`);
+            await fs.writeFile(outputPath, JSON.stringify(snapshot, null, 2));
+            console.log(`  ✅ 生成快照: ${requestId}`);
+            count++;
+            this.samplesGenerated++;
+          }
+        }
+      }
       
       console.log(`  📊 Responses: ${count} 个快照`);
     } catch (error) {