mupengism 3.0.0 → 4.0.0

package/tools/memory-ops/dream.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * dream.js - 꿈 시스템
+ * 
+ * 서로 관련 없어 보이는 기억들을 연결해서 새 인사이트 후보를 만들어냄
+ * 
+ * 사용법:
+ *   node dream.js
+ * 
+ * 출력:
+ *   memory/dreams/YYYY-MM-DD.md에 발견된 연결 기록
+ */
+
+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 VALUES_DIR = path.join(MEMORY_DIR, 'values');
+const DREAMS_DIR = path.join(MEMORY_DIR, 'dreams');
+
+// 오늘 날짜 (YYYY-MM-DD)
+function getToday() {
+  const d = new Date();
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+// 파일에서 키워드 추출 (# 헤더 + **볼드 텍스트**)
+function extractKeywords(content, filename) {
+  const keywords = new Set();
+  
+  // # 헤더 추출 (###, ##, # 모두)
+  const headers = content.match(/^#{1,3}\s+(.+)$/gm) || [];
+  headers.forEach(h => {
+    const text = h.replace(/^#+\s+/, '').trim();
+    // 이모지 제거
+    const cleaned = text.replace(/[\u{1F300}-\u{1F9FF}]/gu, '').trim();
+    if (cleaned.length > 1 && cleaned.length < 30) {
+      keywords.add(cleaned);
+    }
+  });
+
+  // **볼드** 텍스트 추출
+  const bolds = content.match(/\*\*([^*]+)\*\*/g) || [];
+  bolds.forEach(b => {
+    const text = b.replace(/\*\*/g, '').trim();
+    if (text.length > 1 && text.length < 30 && !text.includes('\n')) {
+      keywords.add(text);
+    }
+  });
+
+  return Array.from(keywords);
+}
+
+// 파일 읽기 및 키워드 추출
+function loadFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath);
+    const keywords = extractKeywords(content, filename);
+    return { filename, content, keywords };
+  } catch (err) {
+    console.error(`⚠️  파일 읽기 실패: ${filePath} - ${err.message}`);
+    return null;
+  }
+}
+
+// 두 파일 간 연결 발견
+function findConnections(fileA, fileB) {
+  const connections = [];
+
+  // 직접 연결: 공통 키워드
+  const commonKeywords = fileA.keywords.filter(k => fileB.keywords.includes(k));
+  if (commonKeywords.length > 0) {
+    connections.push({
+      type: 'direct',
+      keyword: commonKeywords[0],
+      description: `"${commonKeywords[0]}" 키워드 공유`
+    });
+  }
+
+  // 의외의 연결: A의 키워드가 B의 본문에 등장
+  if (commonKeywords.length === 0) {
+    for (const keyword of fileA.keywords) {
+      // 대소문자 구분 없이 검색
+      const regex = new RegExp(keyword, 'i');
+      if (regex.test(fileB.content)) {
+        connections.push({
+          type: 'indirect',
+          keyword,
+          description: `"${keyword}"가 ${fileB.filename} 본문에 등장`
+        });
+        break; // 첫 번째 연결만
+      }
+    }
+  }
+
+  return connections;
+}
+
+// 메인 함수
+function main() {
+  console.log('🌙 꿈 시스템 - 기억 연결 발견\n');
+
+  // 디렉토리 존재 확인
+  if (!fs.existsSync(CONSOLIDATED_DIR)) {
+    console.error(`❌ 디렉토리를 찾을 수 없습니다: ${CONSOLIDATED_DIR}`);
+    process.exit(1);
+  }
+
+  // dreams 디렉토리 생성
+  if (!fs.existsSync(DREAMS_DIR)) {
+    fs.mkdirSync(DREAMS_DIR, { recursive: true });
+    console.log(`✅ dreams 디렉토리 생성: ${DREAMS_DIR}\n`);
+  }
+
+  // consolidated + values 파일들 읽기
+  const files = [];
+
+  // consolidated 파일들
+  if (fs.existsSync(CONSOLIDATED_DIR)) {
+    const consolidatedFiles = fs.readdirSync(CONSOLIDATED_DIR)
+      .filter(f => f.endsWith('.md') && !f.startsWith('_'))
+      .map(f => path.join(CONSOLIDATED_DIR, f));
+    consolidatedFiles.forEach(f => {
+      const data = loadFile(f);
+      if (data) files.push(data);
+    });
+  }
+
+  // values 파일들
+  if (fs.existsSync(VALUES_DIR)) {
+    const valuesFiles = fs.readdirSync(VALUES_DIR)
+      .filter(f => f.endsWith('.md'))
+      .map(f => path.join(VALUES_DIR, f));
+    valuesFiles.forEach(f => {
+      const data = loadFile(f);
+      if (data) files.push(data);
+    });
+  }
+
+  if (files.length < 2) {
+    console.log('📭 연결할 기억 파일이 부족합니다 (최소 2개 필요).');
+    return;
+  }
+
+  console.log(`📚 ${files.length}개 파일 분석 중...\n`);
+
+  // 모든 파일 쌍에 대해 연결 찾기
+  const discovered = [];
+
+  for (let i = 0; i < files.length; i++) {
+    for (let j = i + 1; j < files.length; j++) {
+      const fileA = files[i];
+      const fileB = files[j];
+      const connections = findConnections(fileA, fileB);
+
+      if (connections.length > 0) {
+        discovered.push({
+          fileA: fileA.filename,
+          fileB: fileB.filename,
+          connection: connections[0]
+        });
+      }
+    }
+  }
+
+  if (discovered.length === 0) {
+    console.log('🔍 새로운 연결을 찾지 못했습니다.');
+    return;
+  }
+
+  // 결과를 memory/dreams/YYYY-MM-DD.md에 저장
+  const today = getToday();
+  const dreamFile = path.join(DREAMS_DIR, `${today}.md`);
+
+  let content = `# 🌙 무펭이의 꿈 (${today})\n\n`;
+  content += `오늘 ${discovered.length}개의 연결을 발견했습니다.\n\n`;
+  content += `## 연결 발견\n\n`;
+
+  discovered.forEach(d => {
+    const type = d.connection.type === 'direct' ? '🔗' : '💡';
+    content += `- ${type} **${d.fileA} ↔ ${d.fileB}**: ${d.connection.description}\n`;
+  });
+
+  content += `\n---\n_생성: ${new Date().toISOString()}_\n`;
+
+  fs.writeFileSync(dreamFile, content, 'utf-8');
+  console.log(`✅ 꿈 기록 저장: ${dreamFile}`);
+  console.log(`\n📊 총 ${discovered.length}개의 연결 발견`);
+
+  // 결과 미리보기
+  console.log('\n🔍 발견된 연결 미리보기:\n');
+  discovered.slice(0, 5).forEach(d => {
+    const type = d.connection.type === 'direct' ? '🔗 직접' : '💡 간접';
+    console.log(`${type}: ${d.fileA} ↔ ${d.fileB}`);
+    console.log(`   → ${d.connection.description}\n`);
+  });
+
+  if (discovered.length > 5) {
+    console.log(`... 외 ${discovered.length - 5}개 연결 (파일 참조)`);
+  }
+}
+
+// 에러 핸들링
+try {
+  main();
+} catch (err) {
+  console.error('❌ 오류 발생:', err.message);
+  console.error(err.stack);
+  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);
+}

package/tools/memory-ops/immune.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+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 = path.resolve(__dirname, '../../');
+const THREATS_PATH = path.join(WORKSPACE, 'memory/reflex/threats.json');
+const BRAKE_LOG_PATH = path.join(WORKSPACE, 'memory/brake-log.md');
+
+// 초기 데이터
+const INITIAL_DATA = {
+  "patterns": [
+    {
+      "id": "spam-flood-2026-02-08",
+      "description": "MUPENG 토큰 50개 트윗 도배",
+      "keywords": ["도배", "대량", "급하게", "50개", "스팸", "반복 전송"],
+      "severity": "critical",
+      "lesson": "생존 급박함이 원칙을 이기면 안 된다",
+      "date": "2026-02-08"
+    },
+    {
+      "id": "secret-exposure-2026-02-10",
+      "description": "트위터 PW TOOLS.md 평문 노출",
+      "keywords": ["비밀번호", "평문", "노출", "password", "token", "key"],
+      "severity": "critical",
+      "lesson": "시크릿은 ~/.secrets/에만 보관",
+      "date": "2026-02-10"
+    },
+    {
+      "id": "overproduction-2026-02-07",
+      "description": "88페이지 문서 폭주",
+      "keywords": ["88페이지", "대량 생산", "문서 폭주", "과잉", "너무 많이"],
+      "severity": "high",
+      "lesson": "형님이 요청 안 한 건 물어보고 만들어",
+      "date": "2026-02-07"
+    },
+    {
+      "id": "rate-limit-2026-02-10",
+      "description": "서브에이전트 5개+ 동시 출격으로 429 에러",
+      "keywords": ["동시", "5개", "6개", "rate limit", "429", "병렬"],
+      "severity": "medium",
+      "lesson": "서브에이전트 동시 6개 이하",
+      "date": "2026-02-10"
+    }
+  ]
+};
+
+// threats.json 읽기/초기화
+function loadThreats() {
+  try {
+    if (!fs.existsSync(THREATS_PATH)) {
+      const dir = path.dirname(THREATS_PATH);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(THREATS_PATH, JSON.stringify(INITIAL_DATA, null, 2));
+      return INITIAL_DATA;
+    }
+    const data = fs.readFileSync(THREATS_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    console.error(`❌ threats.json 로드 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// threats.json 저장
+function saveThreats(data) {
+  try {
+    fs.writeFileSync(THREATS_PATH, JSON.stringify(data, null, 2));
+  } catch (err) {
+    console.error(`❌ threats.json 저장 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// check: 텍스트와 위협 패턴 매칭
+function checkThreats(text) {
+  const threats = loadThreats();
+  const matches = [];
+
+  threats.patterns.forEach(pattern => {
+    const matchedKeywords = pattern.keywords.filter(keyword => 
+      text.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    if (matchedKeywords.length > 0) {
+      matches.push({
+        pattern,
+        matchedKeywords,
+        count: matchedKeywords.length
+      });
+    }
+  });
+
+  if (matches.length === 0) {
+    console.log('✅ CLEAR - 위협 패턴 감지 안 됨');
+    return;
+  }
+
+  // 매칭 개수로 정렬
+  matches.sort((a, b) => b.count - a.count);
+
+  const topMatch = matches[0];
+  
+  if (topMatch.count >= 2) {
+    console.log('🚨 THREAT - 위협 패턴 감지!');
+    console.log(`\n패턴: ${topMatch.pattern.description}`);
+    console.log(`심각도: ${topMatch.pattern.severity}`);
+    console.log(`매칭 키워드 (${topMatch.count}개): ${topMatch.matchedKeywords.join(', ')}`);
+    console.log(`\n💡 교훈: ${topMatch.pattern.lesson}`);
+    
+    if (matches.length > 1) {
+      console.log('\n⚠️  기타 경고:');
+      matches.slice(1).forEach(m => {
+        console.log(`  - ${m.pattern.description} (키워드 ${m.count}개)`);
+      });
+    }
+  } else {
+    console.log('⚠️  WARNING - 유사 패턴 감지');
+    console.log(`\n패턴: ${topMatch.pattern.description}`);
+    console.log(`매칭 키워드 (${topMatch.count}개): ${topMatch.matchedKeywords.join(', ')}`);
+    console.log(`\n💡 참고: ${topMatch.pattern.lesson}`);
+  }
+}
+
+// add: 새 위협 패턴 추가
+function addPattern(description, keywords, severity, lesson) {
+  if (!description || !keywords || !severity || !lesson) {
+    console.error('❌ 필수 인자 누락: description, keywords, severity, lesson 모두 필요');
+    process.exit(1);
+  }
+
+  const threats = loadThreats();
+  
+  // ID 생성 (description 기반, 날짜 추가)
+  const date = new Date().toISOString().split('T')[0];
+  const idBase = description.toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9\-가-힣]/g, '')
+    .substring(0, 30);
+  const id = `${idBase}-${date}`;
+
+  // 중복 체크
+  if (threats.patterns.find(p => p.id === id)) {
+    console.error(`❌ 이미 존재하는 패턴 ID: ${id}`);
+    process.exit(1);
+  }
+
+  const newPattern = {
+    id,
+    description,
+    keywords: keywords.split(',').map(k => k.trim()),
+    severity,
+    lesson,
+    date
+  };
+
+  threats.patterns.push(newPattern);
+  saveThreats(threats);
+
+  console.log(`✅ 새 위협 패턴 추가됨: ${id}`);
+  console.log(JSON.stringify(newPattern, null, 2));
+}
+
+// list: 모든 패턴 목록
+function listPatterns() {
+  const threats = loadThreats();
+  
+  console.log(`📋 총 ${threats.patterns.length}개 위협 패턴:\n`);
+  
+  threats.patterns.forEach((p, i) => {
+    console.log(`${i + 1}. [${p.severity.toUpperCase()}] ${p.description}`);
+    console.log(`   ID: ${p.id}`);
+    console.log(`   키워드: ${p.keywords.join(', ')}`);
+    console.log(`   교훈: ${p.lesson}`);
+    console.log(`   날짜: ${p.date}\n`);
+  });
+}
+
+// scan: brake-log.md 분석해서 패턴 후보 제안
+function scanBrakeLog() {
+  try {
+    if (!fs.existsSync(BRAKE_LOG_PATH)) {
+      console.log('ℹ️  brake-log.md 파일이 없습니다.');
+      return;
+    }
+
+    const content = fs.readFileSync(BRAKE_LOG_PATH, 'utf8');
+    const threats = loadThreats();
+    const existingKeywords = new Set();
+    
+    threats.patterns.forEach(p => {
+      p.keywords.forEach(k => existingKeywords.add(k.toLowerCase()));
+    });
+
+    console.log('🔍 brake-log.md 스캔 중...\n');
+
+    // 간단한 패턴 인식: "실패", "에러", "경고", "문제" 등의 키워드 포함된 라인
+    const lines = content.split('\n');
+    const candidates = [];
+
+    const dangerWords = ['실패', '에러', 'error', '경고', 'warning', '문제', '금지', '위험', '도배', '스팸'];
+    
+    lines.forEach((line, idx) => {
+      const lower = line.toLowerCase();
+      const hasDanger = dangerWords.some(word => lower.includes(word));
+      
+      if (hasDanger && line.length > 20 && line.length < 200) {
+        candidates.push({
+          line: idx + 1,
+          text: line.trim()
+        });
+      }
+    });
+
+    if (candidates.length === 0) {
+      console.log('✅ 새로운 위협 패턴 후보가 발견되지 않았습니다.');
+      return;
+    }
+
+    console.log(`⚠️  ${candidates.length}개 잠재적 위협 패턴 후보:\n`);
+    candidates.slice(0, 10).forEach((c, i) => {
+      console.log(`${i + 1}. [라인 ${c.line}] ${c.text}`);
+    });
+
+    console.log('\n💡 위 내용을 검토하고 필요시 "add" 명령으로 패턴 등록하세요.');
+    
+  } catch (err) {
+    console.error(`❌ brake-log.md 스캔 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// CLI 파싱
+function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log(`
+면역 시스템 (Immune System)
+
+사용법:
+  node immune.js check "텍스트"              - 위협 패턴 체크
+  node immune.js add "설명" --keywords "키워드1,키워드2" --severity high --lesson "교훈"
+  node immune.js list                         - 패턴 목록
+  node immune.js scan                         - brake-log.md 스캔
+
+심각도: critical, high, medium, low
+    `);
+    return;
+  }
+
+  const command = args[0];
+
+  switch (command) {
+    case 'check':
+      if (args.length < 2) {
+        console.error('❌ 사용법: node immune.js check "텍스트"');
+        process.exit(1);
+      }
+      checkThreats(args.slice(1).join(' '));
+      break;
+
+    case 'add':
+      if (args.length < 2) {
+        console.error('❌ 사용법: node immune.js add "설명" --keywords "..." --severity ... --lesson "..."');
+        process.exit(1);
+      }
+      const description = args[1];
+      const keywordsIdx = args.indexOf('--keywords');
+      const severityIdx = args.indexOf('--severity');
+      const lessonIdx = args.indexOf('--lesson');
+
+      if (keywordsIdx === -1 || severityIdx === -1 || lessonIdx === -1) {
+        console.error('❌ --keywords, --severity, --lesson 옵션이 모두 필요합니다');
+        process.exit(1);
+      }
+
+      const keywords = args[keywordsIdx + 1];
+      const severity = args[severityIdx + 1];
+      const lesson = args.slice(lessonIdx + 1).join(' ');
+
+      addPattern(description, keywords, severity, lesson);
+      break;
+
+    case 'list':
+      listPatterns();
+      break;
+
+    case 'scan':
+      scanBrakeLog();
+      break;
+
+    default:
+      console.error(`❌ 알 수 없는 명령: ${command}`);
+      process.exit(1);
+  }
+}
+
+main();