metame-cli 1.5.21 → 1.5.22

package/scripts/ops-mission-queue.js

@@ -15,7 +15,12 @@ const os = require('os');
 
 const MISSIONS_FILE = 'workspace/missions.md';
 const SECTIONS = ['pending', 'active', 'completed', 'abandoned'];
-const METAME_DIR = path.join(os.homedir(), '.metame');
+const RECENT_LOG_LINES = 500;
+const ERROR_THRESHOLD = 3;
+
+function getMetameDir() {
+  return process.env.METAME_DIR || path.join(os.homedir(), '.metame');
+}
 
 // ── Mission file parser (same format as topic-pool) ──────────
 
@@ -86,6 +91,90 @@ function findMission(sections, id) {
   return null;
 }
 
+function normalizeLogLine(line) {
+  return String(line || '')
+    .replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, '<TS>')
+    .replace(/\d{10,}/g, '<ID>')
+    .replace(/\/tmp\/[^\s]+/g, '<TMP>')
+    .trim();
+}
+
+function collectRecurringErrors() {
+  const counts = {};
+  const logPath = path.join(getMetameDir(), 'daemon.log');
+  if (!fs.existsSync(logPath)) return counts;
+
+  try {
+    const content = fs.readFileSync(logPath, 'utf8');
+    const recent = content.split('\n').slice(-RECENT_LOG_LINES);
+    for (const line of recent) {
+      if (!/\bERR\b|\bWARN\b|\bError\b|\bfailed\b/i.test(line)) continue;
+      const normalized = normalizeLogLine(line);
+      if (normalized.length < 20) continue;
+      const key = normalized.slice(0, 120);
+      counts[key] = (counts[key] || 0) + 1;
+    }
+  } catch { /* ignore unreadable log */ }
+
+  return counts;
+}
+
+function parseRecurringErrorTitle(title) {
+  const m = String(title || '').match(/^Fix recurring error(?:\s*\(\d+x\))?:\s*(.+)$/i);
+  return m ? m[1].trim() : '';
+}
+
+function shouldKeepMission(title, cwd, recurringErrors, now) {
+  const recurringPattern = parseRecurringErrorTitle(title);
+  if (recurringPattern) {
+    return (recurringErrors[recurringPattern] || 0) >= ERROR_THRESHOLD;
+  }
+
+  const testMatch = String(title || '').match(/^Fix failing tests in (.+)$/i);
+  if (testMatch) {
+    const testName = testMatch[1].trim();
+    const testPath = path.join(cwd, 'scripts', testName);
+    if (!fs.existsSync(testPath)) return false;
+    try {
+      execSyncSafe(`node --test scripts/${testName}`, cwd, 30000);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  const staleMatch = String(title || '').match(/^Investigate stale project:\s*(.+)$/i);
+  if (staleMatch) {
+    const projectKey = staleMatch[1].trim();
+    const fp = path.join(getMetameDir(), 'events', `${projectKey}.jsonl`);
+    if (!fs.existsSync(fp)) return false;
+    try {
+      const staleHours = (now - fs.statSync(fp).mtimeMs) / (60 * 60 * 1000);
+      return staleHours > 48;
+    } catch {
+      return true;
+    }
+  }
+
+  return true;
+}
+
+function pruneObsoleteMissions(cwd) {
+  const sections = readSections(cwd);
+  const recurringErrors = collectRecurringErrors();
+  const now = Date.now();
+  const pruned = [];
+
+  sections.pending = sections.pending.filter((mission) => {
+    const keep = shouldKeepMission(mission.title, cwd, recurringErrors, now);
+    if (!keep) pruned.push(mission);
+    return keep;
+  });
+
+  if (pruned.length > 0) writeSections(cwd, sections);
+  return { success: true, pruned: pruned.length, pruned_ids: pruned.map(m => m.id) };
+}
+
 // ── Standard queue commands ──────────────────────────────────
 
 function nextMission(cwd) {
@@ -134,6 +223,7 @@ function listMissions(cwd) {
 // ── Log scanner: generates missions from error patterns ──────
 
 function scanLogs(cwd) {
+  const pruneResult = pruneObsoleteMissions(cwd);
   const sections = readSections(cwd);
   const existingTitles = new Set(
     [...sections.pending, ...sections.active, ...sections.completed, ...sections.abandoned].map(t => t.title)
@@ -141,44 +231,18 @@ function scanLogs(cwd) {
 
   const newMissions = [];
   const now = Date.now();
-  const ONE_DAY = 24 * 60 * 60 * 1000;
+  const recurringErrors = collectRecurringErrors();
 
   // 1. Scan daemon log for repeated errors
-  const logPath = path.join(METAME_DIR, 'daemon.log');
-  if (fs.existsSync(logPath)) {
-    try {
-      const content = fs.readFileSync(logPath, 'utf8');
-      const lines = content.split('\n');
-      // Only look at recent lines (last 500)
-      const recent = lines.slice(-500);
-      const errorCounts = {};
-      for (const line of recent) {
-        if (!/\bERR\b|\bWARN\b|\bError\b|\bfailed\b/i.test(line)) continue;
-        // Normalize: strip timestamps and variable data
-        const normalized = line
-          .replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, '<TS>')
-          .replace(/\d{10,}/g, '<ID>')
-          .replace(/\/tmp\/[^\s]+/g, '<TMP>')
-          .trim();
-        if (normalized.length < 20) continue;
-        const key = normalized.slice(0, 120);
-        errorCounts[key] = (errorCounts[key] || 0) + 1;
-      }
-
-      // Generate missions for errors occurring 3+ times
-      // Dedup key is the pattern alone (not the count, which changes every scan)
-      for (const [pattern, count] of Object.entries(errorCounts)) {
-        if (count < 3) continue;
-        const dedupKey = `Fix recurring error: ${pattern.slice(0, 80)}`;
-        if (existingTitles.has(dedupKey)) continue;
-        // Use stable dedup key as title (count excluded to prevent duplicates)
-        newMissions.push({ title: dedupKey, priority: Math.max(1, 10 - count) });
-      }
-    } catch { /* skip unreadable log */ }
+  for (const [pattern, count] of Object.entries(recurringErrors)) {
+    if (count < ERROR_THRESHOLD) continue;
+    const dedupKey = `Fix recurring error: ${pattern.slice(0, 80)}`;
+    if (existingTitles.has(dedupKey)) continue;
+    newMissions.push({ title: dedupKey, priority: Math.max(1, 10 - count) });
   }
 
   // 2. Scan event logs for stuck/stale projects
-  const eventsDir = path.join(METAME_DIR, 'events');
+  const eventsDir = path.join(getMetameDir(), 'events');
   if (fs.existsSync(eventsDir)) {
     try {
       const evFiles = fs.readdirSync(eventsDir).filter(f => f.endsWith('.jsonl'));
@@ -248,11 +312,12 @@ if (require.main === module) {
     case 'activate': result = args[0] ? activateMission(cwd, args[0]) : { success: false, message: 'usage: activate <id>' }; break;
     case 'complete': result = args[0] ? completeMission(cwd, args[0]) : { success: false, message: 'usage: complete <id>' }; break;
     case 'list':     result = listMissions(cwd); break;
+    case 'prune':    result = pruneObsoleteMissions(cwd); break;
     case 'scan':     result = scanLogs(cwd); break;
-    default:         result = { success: false, message: `unknown: ${command}. Available: next, activate, complete, list, scan` };
+    default:         result = { success: false, message: `unknown: ${command}. Available: next, activate, complete, list, prune, scan` };
   }
 
   process.stdout.write(JSON.stringify(result) + '\n');
 }
 
-module.exports = { nextMission, activateMission, completeMission, listMissions, scanLogs };
+module.exports = { nextMission, activateMission, completeMission, listMissions, pruneObsoleteMissions, scanLogs };

package/scripts/ops-reactive-bootstrap.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const yaml = require('./resolve-yaml');
+const { pruneObsoleteMissions, scanLogs } = require('./ops-mission-queue');
+const { bootstrapReactiveProject } = require('./daemon-reactive-lifecycle');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const CONFIG_PATH = path.join(METAME_DIR, 'daemon.yaml');
+const STATE_PATH = path.join(METAME_DIR, 'daemon_state.json');
+const PROJECT_KEY = 'metame_ops';
+
+function loadConfig() {
+  return yaml.load(fs.readFileSync(CONFIG_PATH, 'utf8')) || {};
+}
+
+function loadState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+  } catch {
+    return { reactive: {}, budget: { tokens_used: 0 } };
+  }
+}
+
+function saveState(state) {
+  fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+}
+
+function checkBudget(config, state) {
+  const budget = config?.daemon?.daily_token_budget;
+  const used = Number(state?.budget?.tokens_used || 0);
+  if (!Number.isFinite(budget) || budget <= 0) return true;
+  return used < budget;
+}
+
+function dispatchReactiveItem(item) {
+  const dispatchBin = path.join(METAME_DIR, 'bin', 'dispatch_to');
+  const args = [dispatchBin];
+  if (item.new_session) args.push('--new');
+  if (item.from) args.push('--from', item.from);
+  args.push(item.target, item.prompt);
+  execFileSync(args[0], args.slice(1), {
+    encoding: 'utf8',
+    timeout: 30000,
+    env: process.env,
+  });
+  return { success: true };
+}
+
+function main() {
+  const config = loadConfig();
+  const project = config?.projects?.[PROJECT_KEY];
+  if (!project || !project.cwd) {
+    process.stdout.write(JSON.stringify({ success: false, skipped: true, reason: 'project_missing' }) + '\n');
+    return;
+  }
+
+  const cwd = project.cwd.replace(/^~/, HOME);
+  const pruned = pruneObsoleteMissions(cwd);
+  const scanned = scanLogs(cwd);
+
+  const result = bootstrapReactiveProject(PROJECT_KEY, config, {
+    metameDir: METAME_DIR,
+    loadState,
+    saveState,
+    checkBudget,
+    handleDispatchItem: dispatchReactiveItem,
+    log: () => {},
+    notifyUser: () => {},
+  });
+
+  process.stdout.write(JSON.stringify({
+    success: true,
+    pruned: pruned.pruned || 0,
+    new_missions: scanned.new_missions || 0,
+    total_pending: scanned.total_pending || 0,
+    bootstrap: result,
+  }) + '\n');
+}
+
+if (require.main === module) main();

package/scripts/hooks/intent-engine.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * MetaMe Intent Engine — Unified UserPromptSubmit Hook
- *
- * Config-driven intent dispatcher. Replaces the standalone team-context.js hook.
- * Each intent module detects a specific pattern and returns a hint string or null.
- * Only injects an additionalSystemPrompt when at least one intent fires.
- *
- * Enabled intents are controlled via daemon.yaml `hooks:` section:
- *
- *   hooks:
- *     team_dispatch: true   # team member communication hints (default: on)
- *     ops_assist: true      # /undo /restart /logs etc. hints (default: on)
- *     task_create: true     # task scheduling hints (default: on)
- *
- * Set any key to false to disable that intent module.
- */
-
-'use strict';
-
-// Global safety net: hooks must NEVER crash or exit non-zero
-process.on('uncaughtException', () => process.exit(0));
-process.on('unhandledRejection', () => process.exit(0));
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const METAME_DIR = path.join(os.homedir(), '.metame');
-const { sanitizePrompt, isInternalPrompt } = require('./hook-utils');
-const { buildIntentHintBlock } = require('../intent-registry');
-
-function exit() { process.exit(0); }
-
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', c => { raw += c; });
-process.stdin.on('end', () => {
-  try { run(JSON.parse(raw)); } catch { exit(); }
-});
-
-function run(data) {
-  // Internal daemon subprocesses set this env flag — never inject hints into them
-  if (process.env.METAME_INTERNAL_PROMPT === '1') return exit();
-
-  const projectKey = process.env.METAME_PROJECT || '';
-  const rawPrompt = (data.prompt || data.user_prompt || '').trim();
-  if (!rawPrompt) return exit();
-
-  // Strip daemon-injected blocks, then bail if this is a system prompt
-  if (isInternalPrompt(rawPrompt)) return exit();
-  const prompt = sanitizePrompt(rawPrompt);
-  if (!prompt) return exit();
-
-  // Load daemon.yaml config (graceful: intents that don't need config still run)
-  let config = {};
-  try {
-    const yaml = require('../resolve-yaml');
-    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8')) || {};
-  } catch { /* proceed with defaults */ }
-
-  let intentBlock = '';
-  try {
-    intentBlock = buildIntentHintBlock(prompt, config, projectKey);
-  } catch {
-    return exit();
-  }
-  if (!intentBlock) return exit();
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalContext: intentBlock },
-  }));
-  exit();
-}

package/scripts/hooks/team-context.js

@@ -1,143 +0,0 @@
-#!/usr/bin/env node
-/**
- * MetaMe Team Context Hook — UserPromptSubmit
- *
- * Detects communication intent towards team members in the prompt.
- * If found, injects targeted dispatch_to hint(s) for only those members.
- * Zero injection when no communication intent detected → zero wasted tokens.
- *
- * Triggers when the prompt contains:
- *   - A communication verb (告诉/让/发给/和...讨论/...) near a member nickname
- *   - Or a member nickname in a communication context
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const METAME_DIR = path.join(os.homedir(), '.metame');
-
-// ── Communication intent patterns ────────────────────────────────────────────
-// Three structural patterns:
-//   A) verb → name:   告诉工匠 / 发给builder / 通知乙
-//   B) name → verb:   工匠你来 / builder帮我 / 乙去做
-//   C) prep + name:   和工匠讨论 / 跟builder说 / 与乙沟通 (name between prep and verb)
-
-const BEFORE_NAME_ZH = ['告诉', '通知', '让', '叫', '派', '交给', '转给', '发给', '联系', '找', '请', '问', '发消息给'];
-const BEFORE_NAME_EN = ['tell', 'ask', 'notify', 'send to', 'assign to', 'delegate to', 'message', 'ping', 'contact'];
-const AFTER_NAME_ZH  = ['你来', '来做', '去做', '帮我', '帮忙', '负责', '处理', '跟进'];
-const AFTER_NAME_EN  = ['help', 'do this', 'handle', 'take care', 'follow up'];
-// Prepositions that introduce a discussion partner (name follows immediately)
-const PREP_ZH = ['和', '跟', '与'];
-const DISC_EN = ['discuss with', 'talk to', 'chat with', 'coordinate with', 'sync with', 'work with'];
-
-function hasCommIntent(text, nickname) {
-  const t = text.toLowerCase();
-  const n = nickname.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-  // A) verb → name (within 15 chars)
-  for (const v of BEFORE_NAME_ZH) {
-    if (new RegExp(`${v}.{0,15}${n}`, 'u').test(t)) return true;
-  }
-  for (const v of BEFORE_NAME_EN) {
-    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
-  }
-
-  // B) name → verb (within 8 chars)
-  for (const v of AFTER_NAME_ZH) {
-    if (new RegExp(`${n}.{0,8}${v}`, 'u').test(t)) return true;
-  }
-  for (const v of AFTER_NAME_EN) {
-    if (new RegExp(`${n}.{0,10}${v}`, 'i').test(t)) return true;
-  }
-
-  // C) prep + name (和工匠/跟builder — prep within 3 chars before name)
-  for (const p of PREP_ZH) {
-    if (new RegExp(`${p}.{0,3}${n}`, 'u').test(t)) return true;
-  }
-  for (const v of DISC_EN) {
-    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
-  }
-
-  return false;
-}
-
-// ── Main ──────────────────────────────────────────────────────────────────────
-function exit() { process.exit(0); }
-
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', c => { raw += c; });
-process.stdin.on('end', () => {
-  try { run(JSON.parse(raw)); } catch { exit(); }
-});
-
-function run(data) {
-  const projectKey = process.env.METAME_PROJECT;
-  if (!projectKey || process.env.METAME_INTERNAL_PROMPT === '1') return exit();
-
-  const prompt = (data.prompt || data.user_prompt || '').trim();
-  if (!prompt) return exit();
-
-  // Load config
-  let config;
-  try {
-    const yaml = require('../resolve-yaml');
-    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8'));
-  } catch { return exit(); }
-
-  if (!config || !config.projects) return exit();
-
-  // Collect all team members across all projects (caller may be top-level or member)
-  const allMembers = [];
-  for (const [parentKey, parent] of Object.entries(config.projects)) {
-    if (!Array.isArray(parent.team)) continue;
-    for (const member of parent.team) {
-      if (member.key === projectKey) continue; // skip self
-      allMembers.push({ member, parentKey, parent });
-    }
-    // Also allow dispatching to parent project itself (escalation)
-    if (parent.team.some(m => m.key === projectKey)) {
-      allMembers.push({
-        member: { key: parentKey, name: parent.name, nicknames: parent.nicknames },
-        parentKey,
-        parent,
-        isParent: true,
-      });
-    }
-  }
-
-  if (allMembers.length === 0) return exit();
-
-  const dispatchBin = path.join(METAME_DIR, 'bin', 'dispatch_to');
-
-  // Find members with communication intent in this prompt
-  const hits = [];
-  for (const { member, isParent } of allMembers) {
-    const nicks = [member.key, member.name, ...(Array.isArray(member.nicknames) ? member.nicknames : [])].filter(Boolean);
-    const matched = nicks.some(n => hasCommIntent(prompt, n));
-    if (matched) hits.push({ member, isParent });
-  }
-
-  if (hits.length === 0) return exit();
-
-  // Build targeted hint for matched members only
-  const lines = hits.map(({ member, isParent }) => {
-    const target = member.peer ? `${member.peer}:${member.key}` : member.key;
-    const location = member.peer ? ` [远端:${member.peer}]` : '';
-    const label = isParent ? `${member.key}（${member.name || member.key}, 向上汇报）` : `${member.key}（${member.name || member.key}${location}）`;
-    return `- ${label}: \`${dispatchBin} --from ${projectKey} ${target} "消息"\``;
-  });
-
-  const hint = [
-    `[团队联络提示]`,
-    `以下成员可通过 dispatch_to 联络:`,
-    ...lines,
-  ].join('\n');
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalSystemPrompt: hint },
-  }));
-  exit();
-}