mupengism 3.1.0 → 4.0.1

package/tools/memory-ops/dream.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+/**
+ * dream.js - 꿈 시스템 (시맨틱 v2)
+ * 
+ * Gemini 임베딩 기반으로 memory 파일 간 의미적 연결을 발견
+ * 표면적으로 다른 주제이지만 깊은 연관성이 있는 것들을 찾아냄
+ * 
+ * 사용법:
+ *   node dream.js
+ *   node dream.js --no-cache    # 캐시 무시하고 전체 재생성
+ * 
+ * 출력:
+ *   memory/dreams/YYYY-MM-DD.md
+ *   memory/dreams/.embed-cache.json (캐시)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// 🔐 무펭이즘 커널 인증
+const { authenticate } = require(path.join(__dirname, '..', 'kernel-guard', 'mupeng-auth.cjs'));
+if (!authenticate()) process.exit(0);
+
+const WORKSPACE = process.env.WORKSPACE || '/Users/mupeng/.openclaw/workspace';
+const MEMORY_DIR = path.join(WORKSPACE, 'memory');
+const DREAMS_DIR = path.join(MEMORY_DIR, 'dreams');
+const CACHE_FILE = path.join(DREAMS_DIR, '.embed-cache.json');
+
+const SCAN_DIRS = [
+  path.join(MEMORY_DIR, 'consolidated'),
+  path.join(MEMORY_DIR, 'values'),
+  path.join(MEMORY_DIR, 'cortex'),
+  path.join(MEMORY_DIR, 'reflex'),
+  path.join(MEMORY_DIR, 'bank'),
+];
+
+// Gemini 임베딩 설정
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY || (() => {
+  // OpenClaw config에서 읽기
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(process.env.HOME, '.openclaw', 'openclaw.json'), 'utf-8'));
+    return cfg?.env?.GEMINI_API_KEY || null;
+  } catch { return null; }
+})();
+const EMBED_MODEL = 'gemini-embedding-001';
+const EMBED_URL = `https://generativelanguage.googleapis.com/v1beta/models/${EMBED_MODEL}:embedContent`;
+
+const CHUNK_SIZE = 600; // 문자
+const MIN_SIM = 0.55;   // Gemini 임베딩은 분포가 다름 — 좀 더 넓게
+const MAX_SIM = 0.82;   // 너무 비슷한 건 당연한 연결
+const TOP_PER_PAIR = 2; // 파일 쌍당 최대 연결 수
+const NO_CACHE = process.argv.includes('--no-cache');
+
+function getToday() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
+}
+
+function md5(text) {
+  return crypto.createHash('md5').update(text).digest('hex');
+}
+
+// 텍스트 → 청크 (문단 기준)
+function chunkText(text) {
+  const chunks = [];
+  const paras = text.split(/\n\n+/);
+  let cur = '';
+  for (const p of paras) {
+    if (cur.length + p.length > CHUNK_SIZE && cur.length > 0) {
+      chunks.push(cur.trim());
+      cur = p;
+    } else {
+      cur += (cur ? '\n\n' : '') + p;
+    }
+  }
+  if (cur.trim()) chunks.push(cur.trim());
+  return chunks.filter(c => c.length > 40);
+}
+
+// Gemini 임베딩 API 호출
+async function embed(text) {
+  const res = await fetch(`${EMBED_URL}?key=${GEMINI_API_KEY}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: `models/${EMBED_MODEL}`,
+      content: { parts: [{ text }] },
+      taskType: 'SEMANTIC_SIMILARITY'
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Gemini API ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  return data.embedding.values;
+}
+
+// 배치 임베딩 (rate limit 대응)
+async function embedBatch(texts) {
+  const results = [];
+  for (let i = 0; i < texts.length; i++) {
+    results.push(await embed(texts[i]));
+    if (i < texts.length - 1) await sleep(80); // rate limit
+  }
+  return results;
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// 코사인 유사도
+function cosine(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+// 캐시
+function loadCache() {
+  if (NO_CACHE) return {};
+  try { return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8')); } catch { return {}; }
+}
+function saveCache(c) {
+  try { fs.writeFileSync(CACHE_FILE, JSON.stringify(c), 'utf-8'); } catch {}
+}
+
+// 핵심 키워드 추출 (빈도 기반, 날짜/숫자/불용어 제외)
+function topKeywords(text, n = 3) {
+  const stopwords = new Set([
+    '있는','하는','되는','위한','통해','대한','에서','으로','것이','있다','없다','한다','이다','하고','에게','때문','그리고','하지만','그래서','또한','이를','수도','해야','같은','아닌','모든','이런','저런','위해','따라','관련','경우','이상','정도','사이','대로','부터','까지','다른',
+    'the','and','for','that','this','with','from','are','was','has','its','not','but','can','will','all','been','have','more','also','into','than','about','when','which','their','would','each','make','like','just','over','such','after','other',
+    'md','http','https','www','com','json','js','true','false','null'
+  ]);
+  const words = text
+    .replace(/[-]{2,}/g, ' ')  // 구분선 제거
+    .replace(/[#*_`\[\](){}|>~=]/g, ' ')  // markdown 제거
+    .replace(/\d{4}[-/.]\d{2}[-/.]\d{2}/g, ' ')  // 날짜 제거
+    .replace(/\b\d+\b/g, ' ')  // 순수 숫자 제거
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(w => w.length > 1 && !stopwords.has(w) && !/^\d+$/.test(w));
+  const freq = {};
+  words.forEach(w => freq[w] = (freq[w] || 0) + 1);
+  return Object.entries(freq).sort((a,b) => b[1] - a[1]).slice(0, n).map(e => e[0]);
+}
+
+// 연결 설명 생성 (더 풍부하게)
+function describeConnection(chunkA, chunkB, sim) {
+  const pct = Math.round(sim * 100);
+  const kwA = topKeywords(chunkA);
+  const kwB = topKeywords(chunkB);
+  const common = kwA.filter(k => kwB.includes(k));
+  
+  if (common.length >= 2) {
+    return `"${common[0]}", "${common[1]}" 주제가 교차 (${pct}%)`;
+  } else if (common.length === 1) {
+    const unique = kwB.find(k => !common.includes(k)) || kwA[1];
+    return `"${common[0]}" 관점에서 "${unique}"과 연결 (${pct}%)`;
+  } else {
+    return `"${kwA[0]}" ↔ "${kwB[0]}" 의미적 공명 (${pct}%)`;
+  }
+}
+
+// 파일 로드
+function loadFiles() {
+  const files = [];
+  for (const dir of SCAN_DIRS) {
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith('.md') || f.startsWith('_') || f.startsWith('.')) continue;
+      try {
+        const fp = path.join(dir, f);
+        const content = fs.readFileSync(fp, 'utf-8');
+        if (content.length < 50) continue; // 너무 짧은 파일 스킵
+        const relDir = path.basename(dir);
+        files.push({ path: fp, name: `${relDir}/${f}`, content });
+      } catch {}
+    }
+  }
+  return files;
+}
+
+async function main() {
+  console.log('🌙 꿈 시스템 v2 — 시맨틱 연결 발견\n');
+
+  if (!GEMINI_API_KEY) {
+    console.error('❌ GEMINI_API_KEY가 없습니다.');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(DREAMS_DIR)) fs.mkdirSync(DREAMS_DIR, { recursive: true });
+
+  const cache = loadCache();
+  const files = loadFiles();
+  
+  if (files.length < 2) {
+    console.log('📭 파일 부족 (최소 2개)');
+    return;
+  }
+
+  console.log(`📚 ${files.length}개 파일 로드 완료\n`);
+
+  // 1. 각 파일 임베딩 생성 (캐시 활용)
+  const fileData = [];
+  let apiCalls = 0;
+
+  for (const file of files) {
+    const hash = md5(file.content);
+    const cacheKey = file.path;
+
+    if (!NO_CACHE && cache[cacheKey]?.hash === hash && cache[cacheKey]?.embeddings?.length > 0) {
+      console.log(`  ✓ 캐시: ${file.name}`);
+      fileData.push({ ...file, embeddings: cache[cacheKey].embeddings });
+      continue;
+    }
+
+    console.log(`  🔄 임베딩: ${file.name}`);
+    const chunks = chunkText(file.content);
+    const embeddings = [];
+
+    for (const chunk of chunks) {
+      try {
+        const vec = await embed(chunk);
+        embeddings.push({ text: chunk, vec });
+        apiCalls++;
+        await sleep(80);
+      } catch (err) {
+        console.error(`    ⚠️ ${err.message}`);
+      }
+    }
+
+    cache[cacheKey] = { hash, embeddings };
+    fileData.push({ ...file, embeddings });
+  }
+
+  saveCache(cache);
+  console.log(`\n💾 캐시 저장 (API 호출: ${apiCalls}회)\n`);
+
+  // 2. 파일 쌍별 시맨틱 연결 탐색
+  console.log('🔍 연결 탐색 중...\n');
+  const results = [];
+
+  for (let i = 0; i < fileData.length; i++) {
+    for (let j = i + 1; j < fileData.length; j++) {
+      const a = fileData[i], b = fileData[j];
+      if (!a.embeddings.length || !b.embeddings.length) continue;
+
+      const connections = [];
+      for (const ca of a.embeddings) {
+        for (const cb of b.embeddings) {
+          const sim = cosine(ca.vec, cb.vec);
+          if (sim >= MIN_SIM && sim <= MAX_SIM) {
+            connections.push({
+              sim,
+              textA: ca.text.substring(0, 120),
+              textB: cb.text.substring(0, 120),
+              desc: describeConnection(ca.text, cb.text, sim)
+            });
+          }
+        }
+      }
+
+      if (connections.length > 0) {
+        connections.sort((x, y) => y.sim - x.sim);
+        results.push({
+          fileA: a.name,
+          fileB: b.name,
+          connections: connections.slice(0, TOP_PER_PAIR)
+        });
+      }
+    }
+  }
+
+  // 전체 결과를 유사도순 정렬
+  results.sort((a, b) => b.connections[0].sim - a.connections[0].sim);
+
+  if (results.length === 0) {
+    console.log('🔍 흥미로운 연결을 찾지 못했습니다.');
+    return;
+  }
+
+  // 3. 결과 저장
+  const today = getToday();
+  const dreamFile = path.join(DREAMS_DIR, `${today}.md`);
+
+  let md = `# 🌙 무펭이의 꿈 (${today})\n\n`;
+  md += `> ${fileData.length}개 파일에서 ${results.length}개 의미적 연결 발견\n`;
+  md += `> 모델: Gemini ${EMBED_MODEL} | 유사도: ${MIN_SIM}–${MAX_SIM}\n\n`;
+
+  // 상위 연결만 하이라이트
+  const top5 = results.slice(0, 5);
+  md += `## 🌟 Top 연결\n\n`;
+  top5.forEach((r, idx) => {
+    md += `### ${idx+1}. ${r.fileA} ↔ ${r.fileB}\n\n`;
+    r.connections.forEach(c => {
+      md += `- **${c.desc}**\n`;
+      md += `  - A: _"${c.textA}..."_\n`;
+      md += `  - B: _"${c.textB}..."_\n\n`;
+    });
+  });
+
+  if (results.length > 5) {
+    md += `## 📋 전체 연결 (${results.length}개)\n\n`;
+    results.slice(5).forEach(r => {
+      const topConn = r.connections[0];
+      md += `- **${r.fileA} ↔ ${r.fileB}**: ${topConn.desc}\n`;
+    });
+    md += '\n';
+  }
+
+  md += `---\n_생성: ${new Date().toISOString()} | API 호출: ${apiCalls}회_\n`;
+
+  fs.writeFileSync(dreamFile, md, 'utf-8');
+  console.log(`✅ 저장: ${dreamFile}`);
+  console.log(`\n📊 ${results.length}개 연결 발견\n`);
+
+  // 미리보기
+  top5.forEach(r => {
+    console.log(`💡 ${r.fileA} ↔ ${r.fileB}`);
+    r.connections.forEach(c => console.log(`   → ${c.desc}`));
+    console.log('');
+  });
+}
+
+main().catch(err => {
+  console.error('❌', err.message);
+  process.exit(1);
+});

package/tools/memory-ops/forget.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * forget.js - 망각 시스템
+ * 
+ * 오래 참조되지 않은 기억에 decay score를 부여하고 아카이브 후보를 제안
+ * 
+ * 사용법:
+ *   node forget.js
+ * 
+ * 출력:
+ *   각 파일의 decay score와 추천 액션 (KEEP / REVIEW / ARCHIVE)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 🔐 무펭이즘 커널 인증
+const { authenticate } = require(path.join(__dirname, '..', 'kernel-guard', 'mupeng-auth.cjs'));
+if (!authenticate()) process.exit(0);
+
+const WORKSPACE = process.env.WORKSPACE || '/Users/mupeng/.openclaw/workspace';
+const MEMORY_DIR = path.join(WORKSPACE, 'memory');
+const CONSOLIDATED_DIR = path.join(MEMORY_DIR, 'consolidated');
+const INDEX_PATH = path.join(MEMORY_DIR, 'index.json');
+
+// decay score 계산
+// days_since_modified * 0.5 + (참조횟수 == 0 ? 30 : 0)
+function calculateDecayScore(lastModifiedMs, referenceCount) {
+  const now = Date.now();
+  const daysSinceModified = Math.floor((now - lastModifiedMs) / (1000 * 60 * 60 * 24));
+  const decayScore = daysSinceModified * 0.5 + (referenceCount === 0 ? 30 : 0);
+  return Math.floor(decayScore);
+}
+
+// 추천 액션 결정
+function recommendAction(score) {
+  if (score > 90) return 'ARCHIVE';
+  if (score > 45) return 'REVIEW';
+  return 'KEEP';
+}
+
+// index.json에서 참조 횟수 계산
+function getReferenceCount(filename, indexData) {
+  let count = 0;
+  const targetPath = `memory/consolidated/${filename}`;
+  
+  if (!indexData || !indexData.tags) {
+    return 0;
+  }
+
+  // tags에서 참조 횟수 계산
+  for (const tag in indexData.tags) {
+    const files = indexData.tags[tag];
+    if (Array.isArray(files) && files.includes(targetPath)) {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+// 메인 함수
+function main() {
+  console.log('🧹 망각 시스템 - 기억 부패 분석\n');
+
+  // consolidated 디렉토리 존재 확인
+  if (!fs.existsSync(CONSOLIDATED_DIR)) {
+    console.error(`❌ 디렉토리를 찾을 수 없습니다: ${CONSOLIDATED_DIR}`);
+    process.exit(1);
+  }
+
+  // index.json 읽기
+  let indexData = null;
+  try {
+    if (fs.existsSync(INDEX_PATH)) {
+      const indexContent = fs.readFileSync(INDEX_PATH, 'utf-8');
+      indexData = JSON.parse(indexContent);
+    }
+  } catch (err) {
+    console.warn(`⚠️  index.json 읽기 실패: ${err.message}`);
+  }
+
+  // consolidated 디렉토리의 .md 파일들 스캔
+  const files = fs.readdirSync(CONSOLIDATED_DIR)
+    .filter(f => f.endsWith('.md') && !f.startsWith('_'))
+    .sort();
+
+  if (files.length === 0) {
+    console.log('📭 분석할 기억 파일이 없습니다.');
+    return;
+  }
+
+  const results = [];
+
+  files.forEach(filename => {
+    const filePath = path.join(CONSOLIDATED_DIR, filename);
+    const stats = fs.statSync(filePath);
+    const lastModifiedMs = stats.mtimeMs;
+    const referenceCount = getReferenceCount(filename, indexData);
+    const decayScore = calculateDecayScore(lastModifiedMs, referenceCount);
+    const action = recommendAction(decayScore);
+
+    results.push({
+      filename,
+      decayScore,
+      referenceCount,
+      lastModified: new Date(lastModifiedMs).toISOString().split('T')[0],
+      action
+    });
+  });
+
+  // 결과 출력 (score 높은 순)
+  results.sort((a, b) => b.decayScore - a.decayScore);
+
+  console.log('파일명                          | Decay | 참조 | 최종수정     | 액션');
+  console.log('--------------------------------|-------|------|--------------|--------');
+
+  results.forEach(r => {
+    const emoji = r.action === 'ARCHIVE' ? '🗄️ ' : r.action === 'REVIEW' ? '🔍' : '✅';
+    const filename = r.filename.padEnd(30);
+    const score = String(r.decayScore).padStart(5);
+    const refs = String(r.referenceCount).padStart(4);
+    const date = r.lastModified.padEnd(12);
+    const action = r.action.padEnd(7);
+    
+    console.log(`${filename} | ${score} | ${refs} | ${date} | ${emoji} ${action}`);
+  });
+
+  // 요약 통계
+  const archiveCount = results.filter(r => r.action === 'ARCHIVE').length;
+  const reviewCount = results.filter(r => r.action === 'REVIEW').length;
+  const keepCount = results.filter(r => r.action === 'KEEP').length;
+
+  console.log('');
+  console.log(`📊 요약: KEEP ${keepCount}개 | REVIEW ${reviewCount}개 | ARCHIVE ${archiveCount}개`);
+  
+  if (archiveCount > 0) {
+    console.log('\n💡 ARCHIVE 후보가 있습니다. 검토 후 수동으로 아카이브하세요.');
+  }
+}
+
+// 에러 핸들링
+try {
+  main();
+} catch (err) {
+  console.error('❌ 오류 발생:', err.message);
+  process.exit(1);
+}