metame-cli 1.3.22 → 1.4.0

package/scripts/distill.js

@@ -12,7 +12,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
+const { callHaiku, buildDistillEnv } = require('./providers');
 
 const HOME = os.homedir();
 const BUFFER_FILE = path.join(HOME, '.metame', 'raw_signals.jsonl');
@@ -31,15 +31,14 @@ try {
 // Provider env for distillation (cheap relay for background tasks)
 let distillEnv = {};
 try {
-  const { buildDistillEnv } = require('./providers');
   distillEnv = buildDistillEnv();
-} catch { /* providers.js not available — use defaults */ }
+} catch { /* providers not configured — use defaults */ }
 
 /**
  * Main distillation process.
  * Returns { updated: boolean, summary: string }
  */
-function distill() {
+async function distill() {
   // 1. Check if buffer exists and has content
   if (!fs.existsSync(BUFFER_FILE)) {
     return { updated: false, behavior: null, summary: 'No signals to process.' };
@@ -55,16 +54,32 @@ function distill() {
     return { updated: false, behavior: null, summary: 'No signals to process.' };
   }
 
-  // 2. Prevent concurrent distillation
-  if (fs.existsSync(LOCK_FILE)) {
-    const lockAge = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
-    if (lockAge < 120000) { // 2 min timeout
-      return { updated: false, behavior: null, summary: 'Distillation already in progress.' };
+  // 2. Prevent concurrent distillation (atomic lock via O_EXCL)
+  let lockFd;
+  try {
+    lockFd = fs.openSync(LOCK_FILE, 'wx');
+    fs.writeSync(lockFd, process.pid.toString());
+    fs.closeSync(lockFd);
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      // Another process holds the lock — check if stale
+      try {
+        const lockAge = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
+        if (lockAge < 120000) {
+          return { updated: false, behavior: null, summary: 'Distillation already in progress.' };
+        }
+        fs.unlinkSync(LOCK_FILE);
+        // Retry once after removing stale lock
+        lockFd = fs.openSync(LOCK_FILE, 'wx');
+        fs.writeSync(lockFd, process.pid.toString());
+        fs.closeSync(lockFd);
+      } catch {
+        return { updated: false, behavior: null, summary: 'Distillation already in progress.' };
+      }
+    } else {
+      throw e;
     }
-    // Stale lock, remove it
-    fs.unlinkSync(LOCK_FILE);
   }
-  fs.writeFileSync(LOCK_FILE, process.pid.toString());
 
   try {
     // 3. Parse signals (preserve confidence from signal-capture)
@@ -134,7 +149,7 @@ function distill() {
     // Goal context section (~11 tokens when present)
     let goalContext = '';
     if (sessionAnalytics) {
-      try { goalContext = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch {}
+      try { goalContext = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch { }
     }
     const goalSection = goalContext ? `\n${goalContext}\n` : '';
 
@@ -156,8 +171,7 @@ RULES:
 2. IGNORE task-specific messages. Only extract what persists across ALL sessions.
 3. Only output fields from WRITABLE FIELDS. Any other key will be rejected.
 4. For enum fields, use one of the listed values.
-5. Episodic exceptions: context.anti_patterns (max 5, cross-project lessons only), context.milestones (max 3).
-6. Strong directives (以后一律/always/never/from now on) → _confidence: high. Otherwise: normal.
+5. Strong directives (以后一律/always/never/from now on) → _confidence: high. Otherwise: normal.
 7. Add _confidence and _source blocks mapping field keys to confidence level and triggering quote.
 8. NEVER extract agent identity or role definitions. Messages like "你是贾维斯/你的角色是.../you are Jarvis" define the AGENT, not the USER. The profile is about the USER's cognition only.
 
@@ -184,19 +198,10 @@ Do NOT repeat existing unchanged values.`;
     // 6. Call Claude in print mode with haiku (+ provider env for relay support)
     let result;
     try {
-      result = execSync(
-        `claude -p --model haiku --no-session-persistence`,
-        {
-          input: distillPrompt,
-          encoding: 'utf8',
-          timeout: 60000, // 60s — runs in background, no rush
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: { ...process.env, ...distillEnv },
-        }
-      ).trim();
+      result = await callHaiku(distillPrompt, distillEnv, 60000);
     } catch (err) {
       // Don't cleanup buffer on API failure — retry next launch
-      try { fs.unlinkSync(LOCK_FILE); } catch {}
+      try { fs.unlinkSync(LOCK_FILE); } catch { }
       const isTimeout = err.killed || (err.signal === 'SIGTERM');
       if (isTimeout) {
         return { updated: false, behavior: null, summary: 'Skipped — API too slow. Will retry next launch.' };
@@ -247,16 +252,13 @@ Do NOT repeat existing unchanged values.`;
       if (Object.keys(filtered).length === 0 && behavior) {
         cleanup();
         if (skeleton && sessionAnalytics) {
-          try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch {}
+          try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch { }
         }
         return { updated: false, behavior, skeleton, signalCount: signals.length, summary: `Analyzed ${signals.length} messages — behavior logged, no profile changes.` };
       }
 
       const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
 
-      // Auto-expire anti_patterns older than 60 days
-      expireAntiPatterns(profile);
-
       // Read raw content to find locked lines and comments
       const rawProfile = fs.readFileSync(BRAIN_FILE, 'utf8');
       const lockedKeys = extractLockedKeys(rawProfile);
@@ -314,7 +316,7 @@ Do NOT repeat existing unchanged values.`;
 
       // Mark session as analyzed after successful distill
       if (skeleton && sessionAnalytics) {
-        try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch {}
+        try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch { }
       }
 
       cleanup();
@@ -446,18 +448,8 @@ function strategicMerge(profile, updates, lockedKeys, pendingTraits, confidenceM
       }
 
       case 'T4':
-        // Stamp added date on anti_pattern entries for auto-expiry
-        if (key === 'context.anti_patterns' && Array.isArray(value)) {
-          const today = new Date().toISOString().slice(0, 10);
-          const existing = getNested(result, key) || [];
-          const existingTexts = new Set(existing.map(e => typeof e === 'string' ? e : e.text));
-          const stamped = value
-            .filter(v => !existingTexts.has(typeof v === 'string' ? v : v.text))
-            .map(v => typeof v === 'string' ? { text: v, added: today } : v);
-          setNested(result, key, [...existing, ...stamped].slice(-5));
-        } else {
-          setNested(result, key, value);
-        }
+        setNested(result, key, value);
+
         // Auto-set focus_since when focus changes
         if (key === 'context.focus') {
           setNested(result, 'context.focus_since', new Date().toISOString().slice(0, 10));
@@ -563,30 +555,14 @@ function truncateArrays(obj) {
   }
 }
 
-/**
- * Auto-expire anti_patterns older than 60 days.
- * Each entry is stored as { text: "...", added: "2026-01-15" } internally.
- * If legacy string entries exist, they are kept (no added date = never expire).
- */
-function expireAntiPatterns(profile) {
-  if (!profile.context || !Array.isArray(profile.context.anti_patterns)) return;
-  const now = Date.now();
-  const SIXTY_DAYS = 60 * 24 * 60 * 60 * 1000;
-  profile.context.anti_patterns = profile.context.anti_patterns.filter(entry => {
-    if (typeof entry === 'string') return true; // legacy, keep
-    if (entry.added) {
-      return (now - new Date(entry.added).getTime()) < SIXTY_DAYS;
-    }
-    return true;
-  });
-}
+
 
 /**
  * Clean up: remove buffer and lock
  */
 function cleanup() {
-  try { fs.unlinkSync(BUFFER_FILE); } catch {}
-  try { fs.unlinkSync(LOCK_FILE); } catch {}
+  try { fs.unlinkSync(BUFFER_FILE); } catch { }
+  try { fs.unlinkSync(LOCK_FILE); } catch { }
 }
 
 // ---------------------------------------------------------
@@ -785,7 +761,7 @@ function bootstrapSessionLog() {
  * Also force-runs after bootstrap (regardless of distill_count).
  * Writes results to profile growth.patterns (max 3).
  */
-function detectPatterns(forceRun) {
+async function detectPatterns(forceRun) {
   const yaml = require('js-yaml');
 
   // Read session log
@@ -822,7 +798,7 @@ function detectPatterns(forceRun) {
   // Read declared goals for pattern context
   let declaredGoals = '';
   if (sessionAnalytics) {
-    try { declaredGoals = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch {}
+    try { declaredGoals = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch { }
   }
   const goalLine = declaredGoals ? `\nUSER'S ${declaredGoals}\n` : '';
 
@@ -856,16 +832,7 @@ patterns:
 If no clear patterns found: respond with exactly NO_PATTERNS`;
 
   try {
-    const result = execSync(
-      `claude -p --model haiku --no-session-persistence`,
-      {
-        input: patternPrompt,
-        encoding: 'utf8',
-        timeout: 30000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, ...distillEnv },
-      }
-    ).trim();
+    const result = await callHaiku(patternPrompt, distillEnv, 30000);
 
     if (!result || result.includes('NO_PATTERNS')) return;
 
@@ -917,39 +884,28 @@ module.exports = { distill, writeSessionLog, bootstrapSessionLog, detectPatterns
 
 // Also allow direct execution
 if (require.main === module) {
-  // Bootstrap: if session_log is thin, batch-fill from history
-  const bootstrapped = bootstrapSessionLog();
-  if (bootstrapped > 0) {
-    console.log(`📊 MetaMe: Bootstrapped ${bootstrapped} historical sessions.`);
-    // Force pattern detection immediately after bootstrap
-    detectPatterns(true);
-  }
-
-  const result = distill();
-  // Write session log if behavior was detected
-  if (result.behavior) {
-    writeSessionLog(result.behavior, result.signalCount || 0, result.skeleton || null, result.sessionSummary || null);
-  }
-  // Run pattern detection (only triggers every 5th distill)
-  if (!bootstrapped) detectPatterns();
-
-  // Skill evolution: cold path — Haiku-powered batch analysis
-  try {
-    const skillEvo = require('./skill-evolution');
-    const evoResult = skillEvo.distillSkills();
-    if (evoResult && (evoResult.updates.length > 0 || evoResult.missing_skills.length > 0)) {
-      console.log(`🧬 Skill evolution: ${evoResult.updates.length} update(s), ${evoResult.missing_skills.length} gap(s) detected.`);
+  (async () => {
+    // Bootstrap: if session_log is thin, batch-fill from history
+    const bootstrapped = bootstrapSessionLog();
+    if (bootstrapped > 0) {
+      console.log(`📊 MetaMe: Bootstrapped ${bootstrapped} historical sessions.`);
+      // Force pattern detection immediately after bootstrap
+      await detectPatterns(true);
     }
-  } catch (e) {
-    // Non-fatal: skill evolution is optional
-    if (e.code !== 'MODULE_NOT_FOUND') {
-      console.log(`⚠️ Skill evolution skipped: ${e.message}`);
+
+    const result = await distill();
+    // Write session log if behavior was detected
+    if (result.behavior) {
+      writeSessionLog(result.behavior, result.signalCount || 0, result.skeleton || null, result.sessionSummary || null);
     }
-  }
 
-  if (result.updated) {
-    console.log(`🧠 ${result.summary}`);
-  } else {
-    console.log(`💤 ${result.summary}`);
-  }
+    // Run pattern detection (only triggers every 5th distill)
+    if (!bootstrapped) await detectPatterns();
+
+    if (result.updated) {
+      console.log(`🧠 ${result.summary}`);
+    } else {
+      console.log(`💤 ${result.summary}`);
+    }
+  })();
 }

package/scripts/feishu-adapter.js

@@ -34,6 +34,29 @@ function withTimeout(promise, ms = 10000) {
   ]);
 }
 
+// Max chars per lark_md element (Feishu limit ~4000)
+const MAX_CHUNK = 3800;
+
+/**
+ * Convert standard markdown to lark_md and split into chunks.
+ * Shared by sendMarkdown and sendCard.
+ */
+function toMdChunks(text) {
+  const content = text
+    .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')      // headers → bold
+    .replace(/^---+$/gm, '─────────────────────');  // hr → unicode line
+  if (content.length <= MAX_CHUNK) return [content];
+  const paragraphs = content.split(/\n\n/);
+  const chunks = [];
+  let buf = '';
+  for (const p of paragraphs) {
+    if (buf.length + p.length + 2 > MAX_CHUNK && buf) { chunks.push(buf); buf = p; }
+    else { buf = buf ? buf + '\n\n' + p : p; }
+  }
+  if (buf) chunks.push(buf);
+  return chunks;
+}
+
 function createBot(config) {
   const { app_id, app_secret } = config;
   if (!app_id || !app_secret) throw new Error('app_id and app_secret are required');
@@ -44,6 +67,17 @@ function createBot(config) {
     appSecret: app_secret,
   });
 
+  // Private: send an interactive card JSON; returns { message_id } or null.
+  // All card functions funnel through here to avoid repeating the SDK call.
+  async function _sendInteractive(chatId, card) {
+    const res = await withTimeout(client.im.message.create({
+      params: { receive_id_type: 'chat_id' },
+      data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
+    }));
+    const msgId = res?.data?.message_id;
+    return msgId ? { message_id: msgId } : null;
+  }
+
   return {
     /**
      * Send a plain text message
@@ -84,119 +118,22 @@ function createBot(config) {
      * Send markdown as Feishu interactive card (lark_md renders bold, lists, code, links)
      */
     async sendMarkdown(chatId, markdown) {
-      // Convert standard markdown → lark_md compatible format
-      let content = markdown
-        .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')   // headers → bold
-        .replace(/^---+$/gm, '─────────────────────');  // hr → unicode line
-
-      // Split into chunks if too long (element limit ~4000 chars)
-      const MAX_CHUNK = 3800;
-      const chunks = [];
-      if (content.length <= MAX_CHUNK) {
-        chunks.push(content);
-      } else {
-        const paragraphs = content.split(/\n\n/);
-        let buf = '';
-        for (const p of paragraphs) {
-          if (buf.length + p.length + 2 > MAX_CHUNK && buf) {
-            chunks.push(buf);
-            buf = p;
-          } else {
-            buf = buf ? buf + '\n\n' + p : p;
-          }
-        }
-        if (buf) chunks.push(buf);
-      }
-
-      // V2 schema: markdown element with normal text size
-      const elements = chunks.map(c => ({
-        tag: 'markdown',
-        content: c,
-        text_size: 'x-large',
-      }));
-
-      const card = {
-        schema: '2.0',
-        body: { elements },
-      };
-
-      const res = await withTimeout(client.im.message.create({
-        params: { receive_id_type: 'chat_id' },
-        data: {
-          receive_id: chatId,
-          msg_type: 'interactive',
-          content: JSON.stringify(card),
-        },
-      }));
-      const msgId = res?.data?.message_id;
-      return msgId ? { message_id: msgId } : null;
+      const elements = toMdChunks(markdown).map(c => ({ tag: 'markdown', content: c }));
+      return _sendInteractive(chatId, { schema: '2.0', body: { elements } });
     },
 
     /**
-     * Send a colored interactive card (for project-tagged notifications)
+     * Send a colored interactive card with optional markdown body (V2 schema)
      * @param {string} chatId
-     * @param {string} title - card header text
-     * @param {string} body - card body (lark markdown)
-     * @param {string} color - header color: blue|orange|green|red|grey|purple|turquoise
+     * @param {object} opts
+     * @param {string} opts.title - card header text
+     * @param {string} [opts.body] - card body (standard markdown)
+     * @param {string} [opts.color='blue'] - header color: blue|orange|green|red|grey|purple|turquoise
      */
     async sendCard(chatId, { title, body, color = 'blue' }) {
-      // Use card schema V2 for better text sizing
-      if (!body) {
-        const card = {
-          schema: '2.0',
-          header: { title: { tag: 'plain_text', content: title }, template: color },
-          body: { elements: [] },
-        };
-        const res = await withTimeout(client.im.message.create({
-          params: { receive_id_type: 'chat_id' },
-          data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
-        }));
-        const msgId = res?.data?.message_id;
-        return msgId ? { message_id: msgId } : null;
-      }
-
-      // Convert standard markdown → lark_md
-      let content = body
-        .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')
-        .replace(/^---+$/gm, '─────────────────────');
-
-      // Split into chunks (lark_md element limit ~4000 chars)
-      const MAX_CHUNK = 3800;
-      const chunks = [];
-      if (content.length <= MAX_CHUNK) {
-        chunks.push(content);
-      } else {
-        const paragraphs = content.split(/\n\n/);
-        let buf = '';
-        for (const p of paragraphs) {
-          if (buf.length + p.length + 2 > MAX_CHUNK && buf) {
-            chunks.push(buf);
-            buf = p;
-          } else {
-            buf = buf ? buf + '\n\n' + p : p;
-          }
-        }
-        if (buf) chunks.push(buf);
-      }
-
-      // V2: use markdown element with text_size for readable font
-      const elements = chunks.map(c => ({
-        tag: 'markdown',
-        content: c,
-        text_size: 'x-large',
-      }));
-
-      const card = {
-        schema: '2.0',
-        header: { title: { tag: 'plain_text', content: title }, template: color },
-        body: { elements },
-      };
-      const res = await withTimeout(client.im.message.create({
-        params: { receive_id_type: 'chat_id' },
-        data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
-      }));
-      const msgId = res?.data?.message_id;
-      return msgId ? { message_id: msgId } : null;
+      const header = { title: { tag: 'plain_text', content: title }, template: color };
+      const elements = body ? toMdChunks(body).map(c => ({ tag: 'markdown', content: c })) : [];
+      return _sendInteractive(chatId, { schema: '2.0', header, body: { elements } });
     },
 
     /**
@@ -214,39 +151,54 @@ function createBot(config) {
     async sendTyping(_chatId) {},
 
     /**
-     * Send interactive card with action buttons
+     * Send interactive card with action buttons (V1 schema — required for card.action.trigger)
      * @param {string} chatId
-     * @param {string} title - card header
+     * @param {string} title - card header (first line) + optional body (remaining lines)
      * @param {Array<Array<{text: string, callback_data: string}>>} buttons - rows of buttons
      */
     async sendButtons(chatId, title, buttons) {
-      // Feishu cards: each action element holds up to 3 buttons.
-      // For a vertical list, put each button in its own action element.
-      const elements = buttons.map(row => ({
+      // Each row becomes one action element; a row can hold up to 3 buttons side-by-side.
+      const buttonElements = buttons.map(row => ({
         tag: 'action',
-        actions: [{
+        actions: row.map(b => ({
           tag: 'button',
-          text: { tag: 'plain_text', content: row[0].text },
+          text: { tag: 'plain_text', content: b.text },
           type: 'default',
-          value: { cmd: row[0].callback_data },
-        }],
+          value: { cmd: b.callback_data },
+        })),
       }));
-      const card = {
+
+      // Feishu card header is single-line — split multi-line title into header + body
+      const lines = title.split('\n');
+      const headerText = lines[0].slice(0, 60);
+      const bodyText = lines.slice(1).join('\n').trim();
+
+      const elements = [];
+      if (bodyText) {
+        elements.push({ tag: 'div', text: { tag: 'lark_md', content: bodyText } });
+        elements.push({ tag: 'hr' });
+      }
+      elements.push(...buttonElements);
+
+      return _sendInteractive(chatId, {
         config: { wide_screen_mode: true },
-        header: {
-          title: { tag: 'plain_text', content: title },
-          template: 'blue',
-        },
+        header: { title: { tag: 'plain_text', content: headerText }, template: 'blue' },
         elements,
-      };
-      await withTimeout(client.im.message.create({
-        params: { receive_id_type: 'chat_id' },
-        data: {
-          receive_id: chatId,
-          msg_type: 'interactive',
-          content: JSON.stringify(card),
-        },
-      }));
+      });
+    },
+
+    /**
+     * Send a rich interactive card with pre-built elements (V1 schema — required for card.action.trigger)
+     * @param {string} chatId
+     * @param {string} headerText - single-line card header
+     * @param {Array} elements - Feishu V1 card elements array
+     */
+    async sendRawCard(chatId, headerText, elements) {
+      return _sendInteractive(chatId, {
+        config: { wide_screen_mode: true },
+        header: { title: { tag: 'plain_text', content: headerText }, template: 'blue' },
+        elements,
+      });
     },
 
     /**