metame-cli 1.4.18 → 1.4.20

package/scripts/self-reflect.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 
 /**
- * self-reflect.js — Weekly Self-Reflection Task
+ * self-reflect.js — Daily Self-Reflection Task
  *
  * Scans correction/metacognitive signals from the past 7 days,
  * aggregates "where did the AI get it wrong", and writes a brief
  * self-critique pattern into growth.patterns in ~/.claude_profile.yaml.
  *
- * Heartbeat: weekly, require_idle, non-blocking.
+ * Also distills correction signals into lessons/ SOP markdown files.
+ *
+ * Heartbeat: nightly at 23:00, require_idle, non-blocking.
  */
 
 'use strict';
@@ -16,13 +18,111 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { callHaiku, buildDistillEnv } = require('./providers');
+const { writeBrainFileSafe } = require('./utils');
 
 const HOME = os.homedir();
 const SIGNAL_FILE = path.join(HOME, '.metame', 'raw_signals.jsonl');
 const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const LOCK_FILE = path.join(HOME, '.metame', 'self-reflect.lock');
+const LESSONS_DIR = path.join(HOME, '.metame', 'memory', 'lessons');
 const WINDOW_DAYS = 7;
 
+/**
+ * Distill correction signals into reusable SOP markdown files.
+ * Each run produces at most one lesson file per unique slug.
+ * Returns the number of lesson files actually written.
+ *
+ * @param {Array} signals - all recent signals (will filter to 'correction' type internally)
+ * @param {string} lessonsDir - absolute path where lesson .md files are written
+ */
+async function generateLessons(signals, lessonsDir) {
+  // Only process correction signals that carry explicit feedback
+  const corrections = signals.filter(s => s.type === 'correction' && s.feedback);
+  if (corrections.length < 2) {
+    console.log(`[self-reflect] Only ${corrections.length} correction signal(s) with feedback, skipping lessons.`);
+    return 0;
+  }
+
+  fs.mkdirSync(lessonsDir, { recursive: true });
+
+  const correctionText = corrections
+    .slice(-15) // cap to avoid prompt bloat
+    .map(c => `- Prompt: ${(c.prompt || '').slice(0, 100)}\n  Feedback: ${(c.feedback || '').slice(0, 150)}`)
+    .join('\n');
+
+  const prompt = `You are distilling correction signals into a reusable SOP for an AI assistant.
+
+Corrections (JSON):
+${correctionText}
+
+Generate ONE actionable lesson in this JSON format:
+{
+  "title": "简短标题（中文，10字以内）",
+  "slug": "kebab-case-english-slug",
+  "content": "## 问题\\n...\\n## 根因\\n...\\n## 操作手册\\n1. ...\\n2. ...\\n3. ..."
+}
+
+Rules: content must be in 中文, concrete and actionable, 100-300 chars total.
+Only output the JSON object, no explanation.`;
+
+  let distillEnv = {};
+  try { distillEnv = buildDistillEnv(); } catch {}
+
+  let result;
+  try {
+    result = await Promise.race([
+      callHaiku(prompt, distillEnv, 60000),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
+    ]);
+  } catch (e) {
+    console.log(`[self-reflect] generateLessons Haiku call failed: ${e.message}`);
+    return 0;
+  }
+
+  let lesson;
+  try {
+    const cleaned = result.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+    lesson = JSON.parse(cleaned);
+    if (!lesson.title || !lesson.slug || !lesson.content) throw new Error('missing fields');
+  } catch (e) {
+    console.log(`[self-reflect] Failed to parse lesson JSON: ${e.message}`);
+    return 0;
+  }
+
+  // Sanitize slug: only lowercase alphanumeric and hyphens
+  const slug = (lesson.slug || '').toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+  if (!slug) {
+    console.log('[self-reflect] generateLessons: empty slug, skipping');
+    return 0;
+  }
+
+  // Prevent duplicates: skip if any existing file already uses this slug
+  const existing = fs.readdirSync(lessonsDir).filter(f => f.endsWith(`-${slug}.md`));
+  if (existing.length > 0) {
+    console.log(`[self-reflect] Lesson '${slug}' already exists (${existing[0]}), skipping.`);
+    return 0;
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const filename = `${today}-${slug}.md`;
+  const filepath = path.join(lessonsDir, filename);
+
+  const fileContent = `---
+date: ${today}
+source: self-reflect
+corrections: ${corrections.length}
+---
+
+# ${lesson.title}
+
+${lesson.content}
+`;
+
+  fs.writeFileSync(filepath, fileContent, 'utf8');
+  console.log(`[self-reflect] Lesson written: ${filepath}`);
+  return 1;
+}
+
 async function run() {
   // Atomic lock
   let lockFd;
@@ -35,7 +135,12 @@ async function run() {
       const age = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
       if (age < 300000) { console.log('[self-reflect] Already running.'); return; }
       fs.unlinkSync(LOCK_FILE);
-      lockFd = fs.openSync(LOCK_FILE, 'wx');
+      try {
+        lockFd = fs.openSync(LOCK_FILE, 'wx');
+      } catch {
+        // Another process acquired the lock
+        return;
+      }
       fs.writeSync(lockFd, process.pid.toString());
       fs.closeSync(lockFd);
     } else throw e;
@@ -105,7 +210,8 @@ ${signalText}
     try {
       result = await Promise.race([
         callHaiku(prompt, distillEnv, 60000),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+        // outer safety net in case callHaiku's internal timeout doesn't propagate
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 90000)),
       ]);
     } catch (e) {
       console.log(`[self-reflect] Haiku call failed: ${e.message}`);
@@ -125,6 +231,16 @@ ${signalText}
       return;
     }
 
+    // === Generate lessons/ from correction signals (independent of patterns result) ===
+    try {
+      const lessonsCount = await generateLessons(recentSignals, LESSONS_DIR);
+      if (lessonsCount > 0) {
+        console.log(`[self-reflect] Generated ${lessonsCount} lesson(s) in ${LESSONS_DIR}`);
+      }
+    } catch (e) {
+      console.log(`[self-reflect] generateLessons failed (non-fatal): ${e.message}`);
+    }
+
     if (patterns.length === 0) {
       console.log('[self-reflect] No patterns found this week.');
       return;
@@ -146,7 +262,7 @@ ${signalText}
 
       // Preserve locked lines (simple approach: only update growth section)
       const dumped = yaml.dump(profile, { lineWidth: -1 });
-      fs.writeFileSync(BRAIN_FILE, dumped, 'utf8');
+      await writeBrainFileSafe(dumped);
       console.log(`[self-reflect] ${patterns.length} pattern(s) written to growth.patterns: ${patterns.join(' | ')}`);
     } catch (e) {
       console.log(`[self-reflect] Failed to write profile: ${e.message}`);

package/scripts/session-analytics.js

@@ -576,17 +576,16 @@ function findSessionById(sessionId) {
  * Read declared goals from the user's profile.
  * Returns a compact string like "DECLARED_GOALS: focus1 | focus2" (~11 tokens).
  */
-function formatGoalContext(profilePath) {
+function formatGoalContext(_profilePath) {
+  // Work state now lives in NOW.md (task whiteboard), not in the profile.
   try {
-    const yaml = require('js-yaml');
-    const profile = yaml.load(fs.readFileSync(profilePath, 'utf8')) || {};
-    const goals = [];
-    if (profile.status && profile.status.focus) goals.push(profile.status.focus);
-    if (profile.context && profile.context.focus && profile.context.focus !== (profile.status && profile.status.focus)) {
-      goals.push(profile.context.focus);
-    }
-    if (goals.length === 0) return '';
-    return `DECLARED_GOALS: ${goals.join(' | ')}`;
+    const nowPath = path.join(HOME, '.metame', 'memory', 'NOW.md');
+    if (!fs.existsSync(nowPath)) return '';
+    const content = fs.readFileSync(nowPath, 'utf8').trim();
+    if (!content) return '';
+    // Truncate to avoid bloating prompts
+    const truncated = content.length > 300 ? content.slice(0, 300) + '…' : content;
+    return `CURRENT_TASK:\n${truncated}`;
   } catch { return ''; }
 }
 

package/scripts/task-board.js

@@ -73,9 +73,15 @@ function createTaskBoard(opts = {}) {
         updated_at          TEXT NOT NULL
       )
     `);
-    try { db.exec("ALTER TABLE tasks ADD COLUMN scope_id TEXT NOT NULL DEFAULT ''"); } catch {}
-    try { db.exec("ALTER TABLE tasks ADD COLUMN task_kind TEXT NOT NULL DEFAULT 'team'"); } catch {}
-    try { db.exec("ALTER TABLE tasks ADD COLUMN participants TEXT NOT NULL DEFAULT '[]'"); } catch {}
+    for (const col of [
+      "ALTER TABLE tasks ADD COLUMN scope_id TEXT NOT NULL DEFAULT ''",
+      "ALTER TABLE tasks ADD COLUMN task_kind TEXT NOT NULL DEFAULT 'team'",
+      "ALTER TABLE tasks ADD COLUMN participants TEXT NOT NULL DEFAULT '[]'",
+    ]) {
+      try { db.exec(col); } catch (e) {
+        if (!e.message.includes('duplicate column name')) throw e;
+      }
+    }
 
     db.exec(`
       CREATE TABLE IF NOT EXISTS handoffs (

package/scripts/telegram-adapter.js

@@ -122,19 +122,21 @@ function createBot(token) {
      * @param {string} markdown - Markdown text
      */
     async sendMarkdown(chatId, markdown) {
-      const chunks = splitMessage(markdown, 4096);
+      // Convert first, then split — avoids mid-token cuts and length underestimation
+      const converted = toTelegramMarkdownV2(markdown);
+      const chunks = splitMessage(converted, 4096);
       for (const chunk of chunks) {
         try {
           await apiRequest(token, 'sendMessage', {
             chat_id: chatId,
             text: chunk,
-            parse_mode: 'Markdown',
+            parse_mode: 'MarkdownV2',
           });
         } catch {
-          // Fallback to plain text if markdown parsing fails
+          // Fallback: send stripped plain text
           await apiRequest(token, 'sendMessage', {
             chat_id: chatId,
-            text: chunk,
+            text: stripMarkdown(markdown).slice(0, 4096),
           });
         }
       }
@@ -179,11 +181,21 @@ function createBot(token) {
      * @param {string} text
      */
     async editMessage(chatId, messageId, text) {
-      await apiRequest(token, 'editMessageText', {
-        chat_id: chatId,
-        message_id: messageId,
-        text: text.slice(0, 4096),
-      });
+      const converted = toTelegramMarkdownV2(text).slice(0, 4096);
+      try {
+        await apiRequest(token, 'editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          text: converted,
+          parse_mode: 'MarkdownV2',
+        });
+      } catch {
+        await apiRequest(token, 'editMessageText', {
+          chat_id: chatId,
+          message_id: messageId,
+          text: stripMarkdown(text).slice(0, 4096),
+        });
+      }
     },
 
     /**
@@ -336,4 +348,60 @@ function splitMessage(text, maxLen) {
   return chunks;
 }
 
+/**
+ * Convert standard Markdown to Telegram MarkdownV2 format.
+ *
+ * Mapping:  **bold** → *bold*,  *italic* → _italic_,  # Heading → *Heading*
+ * All MarkdownV2 special chars in plain text are escaped with backslash.
+ */
+function toTelegramMarkdownV2(md) {
+  const escapePlain = s => s.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1');
+
+  // Order matters: code blocks → inline code → bold (before italic) → links → headings → blockquotes
+  // Note: bold uses [\s\S]+? to allow * inside; _italic_ only matches boundary underscores
+  //   (_[^_\n]+_ would match snake_case — use word-boundary aware pattern instead)
+  const pattern = /```(?:\w*\n?)?([\s\S]*?)```|`([^`\n]+)`|\*\*([\s\S]+?)\*\*|\*([^*\n]+)\*|(?<!\w)_([^_\n]+)_(?!\w)|\[([^\]]+)\]\(([^)\s]+)\)|^(#{1,6}) (.+)$|^(>.+(?:\n>.*)*)$/mg;
+
+  let out = '';
+  let last = 0;
+  let m;
+
+  while ((m = pattern.exec(md)) !== null) {
+    if (m.index > last) out += escapePlain(md.slice(last, m.index));
+
+    if      (m[1] !== undefined) out += '```' + m[1].replace(/[`\\]/g, '\\$&') + '```';
+    else if (m[2] !== undefined) out += '`'   + m[2].replace(/[`\\]/g, '\\$&') + '`';
+    else if (m[3] !== undefined) out += '*'   + toTelegramMarkdownV2(m[3]) + '*';
+    else if (m[4] !== undefined) out += '_'   + toTelegramMarkdownV2(m[4]) + '_';
+    else if (m[5] !== undefined) out += '_'   + toTelegramMarkdownV2(m[5]) + '_';
+    else if (m[6] !== undefined) out += '[' + toTelegramMarkdownV2(m[6]) + '](' + m[7].replace(/[()\\]/g, '\\$&') + ')';
+    else if (m[9] !== undefined) out += '*' + escapePlain(m[9]) + '*';
+    else if (m[10] !== undefined) {
+      // > blockquote — prefix each line with TG quote syntax
+      const lines = m[10].split('\n').map(l => '>' + escapePlain(l.replace(/^>\s?/, '')));
+      out += lines.join('\n');
+    }
+
+    last = m.index + m[0].length;
+  }
+
+  if (last < md.length) out += escapePlain(md.slice(last));
+  return out;
+}
+
+/**
+ * Strip all Markdown formatting, returning plain text.
+ * Used as fallback when MarkdownV2 rendering fails.
+ */
+function stripMarkdown(md) {
+  return md
+    .replace(/```[\s\S]*?```/g, m => m.replace(/^```\w*\n?/, '').replace(/```$/, ''))
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/\*([^*\n]+)\*/g, '$1')
+    .replace(/_([^_\n]+)_/g, '$1')
+    .replace(/^#{1,6} (.+)$/mg, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+}
+
 module.exports = { createBot };