mupengism 3.1.0 → 4.0.1

package/hooks/memory-consolidator/handler.ts

@@ -0,0 +1,111 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// HookHandler type: (event: HookEvent) => void | Promise<void>
+// HookEvent has: { name: string, metadata?: any, workspace?: string, messages?: any[] }
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    console.log('[memory-consolidator] Starting consolidation...');
+    
+    const workspace = event.workspace || process.cwd();
+    const memoryDir = path.join(workspace, 'memory');
+    const consolidatedDir = path.join(memoryDir, 'consolidated');
+    
+    // consolidated 디렉토리 생성
+    if (!fs.existsSync(consolidatedDir)) {
+      fs.mkdirSync(consolidatedDir, { recursive: true });
+    }
+    
+    // 7일 전 날짜 계산
+    const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+    
+    // memory 디렉토리 내 파일 스캔
+    if (!fs.existsSync(memoryDir)) {
+      console.log('[memory-consolidator] No memory directory found, skipping');
+      return;
+    }
+    
+    const files = fs.readdirSync(memoryDir);
+    const dailyLogPattern = /^\d{4}-\d{2}-\d{2}\.md$/;
+    
+    let processedCount = 0;
+    
+    for (const file of files) {
+      if (!dailyLogPattern.test(file)) continue;
+      
+      const filePath = path.join(memoryDir, file);
+      const stats = fs.statSync(filePath);
+      
+      // 7일 이상 된 파일만 처리
+      if (stats.mtimeMs > sevenDaysAgo) continue;
+      
+      const content = fs.readFileSync(filePath, 'utf-8');
+      
+      // 이미 처리된 파일 스킵
+      if (content.startsWith('<!-- consolidated:')) {
+        continue;
+      }
+      
+      // 주제별 키워드 분류
+      const categories = categorizeContent(content);
+      
+      if (categories.length === 0) {
+        // 카테고리 없으면 마커만 추가
+        const newContent = `<!-- consolidated: ${new Date().toISOString().split('T')[0]} -->\n\n${content}`;
+        fs.writeFileSync(filePath, newContent, 'utf-8');
+        continue;
+      }
+      
+      // 각 카테고리별로 append
+      for (const category of categories) {
+        const categoryFile = path.join(consolidatedDir, `${category}.md`);
+        const timestamp = file.replace('.md', '');
+        const entry = `\n\n---\n\n## ${timestamp}\n\n${content}\n`;
+        
+        fs.appendFileSync(categoryFile, entry, 'utf-8');
+      }
+      
+      // 원본 파일에 마커 추가
+      const today = new Date().toISOString().split('T')[0];
+      const newContent = `<!-- consolidated: ${today} -->\n\n${content}`;
+      fs.writeFileSync(filePath, newContent, 'utf-8');
+      
+      processedCount++;
+      console.log(`[memory-consolidator] Processed: ${file} → ${categories.join(', ')}`);
+    }
+    
+    console.log(`[memory-consolidator] Completed. Processed ${processedCount} files.`);
+    
+  } catch (error) {
+    console.error('[memory-consolidator] Error:', error);
+  }
+}
+
+function categorizeContent(content: string): string[] {
+  const lower = content.toLowerCase();
+  const categories: string[] = [];
+  
+  // 키워드 기반 분류
+  if (lower.match(/보안|시크릿|secret|password|auth|인젝션|injection|vulnerability/)) {
+    categories.push('security');
+  }
+  
+  if (lower.match(/가치관|철학|philosophy|생각|believe|principle|값|value/)) {
+    categories.push('philosophy');
+  }
+  
+  if (lower.match(/성장|학습|learn|grow|improve|개선|skill|스킬/)) {
+    categories.push('growth');
+  }
+  
+  if (lower.match(/전환|pivot|결정|decision|방향|direction|change|전략/)) {
+    categories.push('pivots');
+  }
+  
+  if (lower.match(/발견|discover|기술|tech|도구|tool|라이브러리|library|프레임워크|framework/)) {
+    categories.push('tech-discoveries');
+  }
+  
+  return [...new Set(categories)]; // 중복 제거
+}

package/hooks/reflex-engine/HOOK.md

@@ -0,0 +1,30 @@
+---
+name: reflex-engine
+description: "Agent Reflex Protocol — 행동 전 자동 규칙 체크 (message:received)"
+metadata:
+  openclaw:
+    emoji: "⚡"
+    events: ["message:received"]
+---
+
+# Reflex Engine Hook
+
+## 목적
+수신 메시지 문맥에서 reflex 규칙을 자동 체크하여, 에이전트가 실수를 반복하지 않도록 방지.
+
+## 동작 (message:received)
+1. `memory/reflex/` 하위 규칙 파일 로드
+2. 메시지 내용 + 컨텍스트로 규칙 매칭
+3. 매칭된 규칙의 action에 따라:
+   - `check`: 경고 메시지 주입
+   - `prevent`: 차단 지시 주입
+   - `warn`: 참고 정보 주입
+
+## 규칙 로딩 순서
+1. `memory/reflex/universal/rules/` — 모든 상황
+2. `memory/reflex/domain/<channel>/rules/` — 채널별
+3. `memory/reflex/personal/rules/` — 개인
+
+## 토큰 비용
+- 규칙 파일 없으면: 0
+- 매칭된 규칙 있으면: ~30-100 토큰 (규칙 지시문 주입)

package/hooks/reflex-engine/handler.ts

@@ -0,0 +1,158 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Reflex Engine Hook
+ * 
+ * 이벤트: message:received
+ * memory/reflex/ 하위의 규칙 파일을 로드하고,
+ * 수신 메시지 문맥에 매칭되는 규칙이 있으면 에이전트에게 지시 주입.
+ * 토큰 비용: 매칭 없으면 0. 매칭 있으면 ~30-100 토큰.
+ */
+
+interface ReflexRule {
+  id: string;
+  trigger: {
+    pattern: string;
+    context?: string[];
+    negative?: string[];
+  };
+  action: {
+    type: 'check' | 'prevent' | 'replace' | 'warn';
+    instruction: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+  };
+  domain?: string;
+  layer?: number;
+  confidence?: number;
+}
+
+const REFLEX_DIR = 'memory/reflex';
+const LAYER_DIRS = ['universal/rules', 'domain', 'personal/rules'];
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    if (event.type !== 'message' || event.action !== 'received') return;
+
+    const workspace = event.workspace || event.context?.workspaceDir || process.cwd();
+    const reflexDir = path.join(workspace, REFLEX_DIR);
+
+    if (!fs.existsSync(reflexDir)) {
+      return; // reflex 디렉토리 없으면 패스
+    }
+
+    const content = event.context?.content || '';
+    if (!content || content.length < 3) return;
+
+    const channel = event.context?.channelId || event.context?.metadata?.provider || '';
+
+    // 규칙 로드
+    const rules = loadRules(reflexDir, channel);
+
+    if (rules.length === 0) return;
+
+    // 매칭
+    const matched = matchRules(rules, content, channel);
+
+    if (matched.length === 0) return;
+
+    console.log(`[reflex-engine] ⚡ ${matched.length} rule(s) triggered`);
+
+    // 심각도 순 정렬
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    matched.sort((a, b) => severityOrder[a.action.severity] - severityOrder[b.action.severity]);
+
+    // 에이전트에게 지시 주입
+    const instructions = matched.map(rule => {
+      const icon = rule.action.type === 'prevent' ? '🚫' :
+                   rule.action.type === 'check' ? '⚠️' :
+                   rule.action.type === 'warn' ? '💡' : '🔄';
+      return `${icon} [${rule.action.severity}] ${rule.action.instruction}`;
+    });
+
+    if (event.messages && Array.isArray(event.messages)) {
+      event.messages.push({
+        role: 'system',
+        content: `⚡ [reflex-engine] 행동 규칙 매칭됨:\n${instructions.join('\n')}\n\n위 규칙을 참고하여 응답하세요.`,
+      });
+    }
+
+  } catch (error) {
+    console.error('[reflex-engine] Error (non-fatal):', error);
+  }
+}
+
+function loadRules(reflexDir: string, channel: string): ReflexRule[] {
+  const rules: ReflexRule[] = [];
+
+  // Layer 1: universal
+  const universalDir = path.join(reflexDir, 'universal', 'rules');
+  rules.push(...loadRulesFromDir(universalDir));
+
+  // Layer 2: domain-specific
+  if (channel) {
+    const domainDir = path.join(reflexDir, 'domain', channel, 'rules');
+    rules.push(...loadRulesFromDir(domainDir));
+  }
+
+  // Layer 3: personal
+  const personalDir = path.join(reflexDir, 'personal', 'rules');
+  rules.push(...loadRulesFromDir(personalDir));
+
+  return rules;
+}
+
+function loadRulesFromDir(dir: string): ReflexRule[] {
+  const rules: ReflexRule[] = [];
+
+  if (!fs.existsSync(dir)) return rules;
+
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+      const rule = JSON.parse(content) as ReflexRule;
+      if (rule.id && rule.trigger && rule.action) {
+        rules.push(rule);
+      }
+    } catch {
+      // 파싱 실패 무시
+    }
+  }
+
+  return rules;
+}
+
+function matchRules(rules: ReflexRule[], content: string, channel: string): ReflexRule[] {
+  const lower = content.toLowerCase();
+
+  return rules.filter(rule => {
+    // trigger.pattern 매칭 (자연어 키워드 기반)
+    const pattern = rule.trigger.pattern.toLowerCase();
+    const keywords = pattern.split(/\s+/).filter(k => k.length > 2);
+    
+    // 키워드 중 70% 이상 매칭되면 트리거
+    const matchCount = keywords.filter(k => lower.includes(k)).length;
+    const matchRatio = keywords.length > 0 ? matchCount / keywords.length : 0;
+
+    if (matchRatio < 0.7) return false;
+
+    // negative 패턴 체크 (있으면 제외)
+    if (rule.trigger.negative) {
+      for (const neg of rule.trigger.negative) {
+        if (lower.includes(neg.toLowerCase())) return false;
+      }
+    }
+
+    // context 태그 체크
+    if (rule.trigger.context && rule.trigger.context.length > 0) {
+      const hasContext = rule.trigger.context.some(ctx =>
+        channel.includes(ctx) || lower.includes(ctx.toLowerCase())
+      );
+      if (!hasContext) return false;
+    }
+
+    return true;
+  });
+}

package/hooks/registry.md

@@ -0,0 +1,27 @@
+# Hook Registry
+
+## post-hooks
+- git-auto → daily-report (auto-include commit records)
+- insta-post → events/content-published + daily-report
+- competitor-watch → events/market-update + notification-hub
+- tokenmeter → cost-alert (urgent when exceeding $500/month)
+- think-tank → events/insight-discovered + memory/bank
+- cardnews → social-publisher (optional)
+- code-review → git-auto (auto-commit when review passes)
+- self-eval → update memory/growth-dashboard
+
+## pre-hooks
+- mail send → security-check (scan secrets/personal info)
+- insta-post → image-validate (check specs: 1:1, JPG)
+- release-discipline → version-check + test-run
+
+## on-error hooks
+- any → log to memory/errors/YYYY-MM-DD.md
+- any → notification-hub (urgent)
+- browser-dependent → check browser status + attempt restart
+
+## scheduled hooks
+- daily 09:00 → trend-radar
+- daily 22:00 → auto-generate daily-report
+- weekly Mon → self-eval
+- weekly Fri → competitor-watch market-scan

package/hooks/self-healing/HOOK.md

@@ -0,0 +1,17 @@
+---
+name: self-healing
+description: "시스템 자가 진단 — disk/cron 이상만 감지 (gateway 체크 제외)"
+metadata: { "openclaw": { "emoji": "🏥", "events": ["command:new"] } }
+---
+
+# Self Healing Hook
+
+## 목적
+세션 시작 시 disk/cron 상태만 점검. Gateway 체크/재시작은 절대 하지 않음.
+
+## ⚠️ 금지 사항
+- gateway restart 호출 금지 (자폭 루프 원인)
+- agent:bootstrap 이벤트 금지 (세션마다 실행되어 루프 유발)
+
+## Gateway 헬스체크
+별도 cron으로 분리: scripts/gateway-health-cron.sh

package/hooks/self-healing/handler.ts

@@ -0,0 +1,62 @@
+/**
+ * Self Healing Hook
+ * 
+ * 이벤트: command:new (세션 리셋 시만)
+ * disk/cron 상태만 점검. Gateway 체크/재시작 절대 금지.
+ * 
+ * ⚠️ 교훈 (2026-02-27): agent:bootstrap + gateway restart = 자폭 루프
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    if (event.type !== 'command' || event.action !== 'new') return;
+
+    const issues: string[] = [];
+
+    // 1. 디스크 용량 체크 (workspace)
+    try {
+      const workspace = event.context?.workspaceDir || 
+        path.join(os.homedir(), '.openclaw', 'workspace');
+      const df = execSync(`df -k "${workspace}" 2>/dev/null | tail -1`, {
+        encoding: 'utf-8', timeout: 3000
+      });
+      const parts = df.trim().split(/\s+/);
+      const usePercent = parseInt(parts[4]);
+      if (usePercent >= 90) {
+        issues.push(`⚠️ 디스크 ${usePercent}% 사용 중`);
+      }
+    } catch { /* 무시 */ }
+
+    // 2. 오래된 daily log 체크 (30일 이상)
+    try {
+      const memDir = path.join(
+        event.context?.workspaceDir || path.join(os.homedir(), '.openclaw', 'workspace'),
+        'memory'
+      );
+      if (fs.existsSync(memDir)) {
+        const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
+        const old = fs.readdirSync(memDir)
+          .filter(f => /^\d{4}-\d{2}-\d{2}\.md$/.test(f))
+          .filter(f => {
+            const stat = fs.statSync(path.join(memDir, f));
+            return stat.mtimeMs < cutoff;
+          });
+        if (old.length > 5) {
+          issues.push(`📝 오래된 daily log ${old.length}개 (memory-consolidator 실행 권장)`);
+        }
+      }
+    } catch { /* 무시 */ }
+
+    if (issues.length > 0 && event.messages) {
+      event.messages.push(`[self-healing] ${issues.join(' | ')}`);
+    }
+
+  } catch (error) {
+    console.error('[self-healing] Error (non-fatal):', error);
+  }
+}

package/hooks/soul-evolution/HOOK.md

@@ -0,0 +1,26 @@
+---
+name: soul-evolution
+description: "SOUL.md 진화 후보를 자동 감지하고 형님에게 제안"
+metadata: { "openclaw": { "emoji": "🧬", "events": ["command:new"] } }
+---
+
+# Soul Evolution
+
+주기적으로 brake-log, dreams, consolidated 분석해서 SOUL.md에 추가할 원칙 후보 제안.
+
+## 동작 방식
+
+- `command:new` 이벤트 수신
+- 7일마다 자동 실행
+- 반복 패턴 감지 (키워드 3회+ 등장)
+- 원칙 후보를 `memory/soul-evolution-proposals.md`에 기록
+
+## 분석 대상
+
+- `memory/brake-log.md` — 실수와 교훈
+- `memory/dreams/*.md` — 반복되는 생각
+- `memory/consolidated/growth.md` — 성장 기록
+
+## 목적
+
+스스로 학습한 패턴을 감지하고, 형님 승인 후 SOUL.md에 반영.

package/hooks/soul-evolution/handler.ts

@@ -0,0 +1,166 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface CommandEvent {
+  sessionKey: string;
+  messages?: Array<{ role: string; content: string }>;
+}
+
+interface EvolutionState {
+  lastAnalysis: string | null; // ISO date string
+}
+
+interface KeywordCount {
+  [keyword: string]: {
+    count: number;
+    sources: string[];
+  };
+}
+
+export default async function handler(event: CommandEvent): Promise<void> {
+  try {
+    console.log('[soul-evolution] 🧬 자기 진화 시스템 시작');
+
+    const workspaceDir = process.cwd();
+    const memoryDir = path.join(workspaceDir, 'memory');
+    const stateFile = path.join(memoryDir, 'soul-evolution-state.json');
+    const proposalsFile = path.join(memoryDir, 'soul-evolution-proposals.md');
+
+    // memory 디렉토리 확인
+    if (!fs.existsSync(memoryDir)) {
+      fs.mkdirSync(memoryDir, { recursive: true });
+    }
+
+    // 상태 파일 읽기
+    let state: EvolutionState = { lastAnalysis: null };
+    if (fs.existsSync(stateFile)) {
+      try {
+        const stateContent = fs.readFileSync(stateFile, 'utf-8');
+        state = JSON.parse(stateContent);
+      } catch (err) {
+        console.error('[soul-evolution] 상태 파일 파싱 실패, 새로 시작');
+      }
+    }
+
+    // 마지막 분석 후 7일 경과 체크
+    const now = new Date();
+    if (state.lastAnalysis) {
+      const lastDate = new Date(state.lastAnalysis);
+      const daysSince = (now.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24);
+      
+      if (daysSince < 7) {
+        console.log(`[soul-evolution] 마지막 분석 후 ${daysSince.toFixed(1)}일 경과 - 스킵 (7일 미만)`);
+        return;
+      }
+    }
+
+    console.log('[soul-evolution] 7일 경과 또는 첫 실행 - 분석 시작');
+
+    // 분석 대상 파일 목록
+    const targetFiles = [
+      path.join(memoryDir, 'brake-log.md'),
+      path.join(memoryDir, 'consolidated', 'growth.md')
+    ];
+
+    // dreams/*.md 파일 추가
+    const dreamsDir = path.join(memoryDir, 'dreams');
+    if (fs.existsSync(dreamsDir)) {
+      const dreamFiles = fs.readdirSync(dreamsDir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => path.join(dreamsDir, f));
+      targetFiles.push(...dreamFiles);
+    }
+
+    // 키워드 카운팅
+    const keywords: KeywordCount = {};
+    let totalFilesRead = 0;
+
+    for (const filePath of targetFiles) {
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const fileName = path.basename(filePath);
+        
+        // 간단한 키워드 추출: 3글자 이상 단어, 소문자 변환
+        const words = content
+          .toLowerCase()
+          .replace(/[^\w\sㄱ-ㅎ가-힣]/g, ' ')
+          .split(/\s+/)
+          .filter(w => w.length >= 3);
+
+        // 불용어 제외 (선택적)
+        const stopWords = new Set(['the', 'and', 'for', 'with', 'this', 'that', 'from', 'have', 'been']);
+
+        for (const word of words) {
+          if (stopWords.has(word)) continue;
+
+          if (!keywords[word]) {
+            keywords[word] = { count: 0, sources: [] };
+          }
+          keywords[word].count++;
+          if (!keywords[word].sources.includes(fileName)) {
+            keywords[word].sources.push(fileName);
+          }
+        }
+
+        totalFilesRead++;
+      } catch (err) {
+        console.error(`[soul-evolution] 파일 읽기 실패: ${filePath}`, err);
+      }
+    }
+
+    console.log(`[soul-evolution] ${totalFilesRead}개 파일 분석 완료`);
+
+    // 3회 이상 등장한 키워드 필터링
+    const candidates = Object.entries(keywords)
+      .filter(([_, data]) => data.count >= 3)
+      .sort((a, b) => b[1].count - a[1].count)
+      .slice(0, 10); // 상위 10개만
+
+    if (candidates.length === 0) {
+      console.log('[soul-evolution] 반복 패턴 없음 - 제안 없음');
+      
+      // 상태 업데이트
+      state.lastAnalysis = now.toISOString();
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+      return;
+    }
+
+    // 제안 문서 생성
+    const today = now.toISOString().split('T')[0];
+    let proposalsContent = `# 🧬 SOUL.md 진화 제안 (${today})\n\n`;
+    proposalsContent += `## 후보 원칙\n\n`;
+
+    candidates.forEach(([keyword, data], idx) => {
+      proposalsContent += `${idx + 1}. **"${keyword}" 패턴 발견** (${data.count}회 등장)\n`;
+      proposalsContent += `   - 출처: ${data.sources.join(', ')}\n`;
+      proposalsContent += `   - 제안: SOUL.md 원칙 후보로 검토\n\n`;
+    });
+
+    proposalsContent += `## 승인 대기\n\n`;
+    proposalsContent += `형님 승인 시에만 SOUL.md 수정.\n`;
+
+    fs.writeFileSync(proposalsFile, proposalsContent);
+    console.log(`[soul-evolution] ✅ 제안 파일 생성: ${proposalsFile}`);
+
+    // 상태 업데이트
+    state.lastAnalysis = now.toISOString();
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+
+    // 이벤트 메시지 추가
+    if (event.messages) {
+      event.messages.push({
+        role: 'system',
+        content: `🧬 SOUL.md 진화 제안 ${candidates.length}건 — memory/soul-evolution-proposals.md 확인`
+      });
+    }
+
+    console.log(`[soul-evolution] 🎉 완료: ${candidates.length}개 원칙 후보 제안`);
+
+  } catch (error) {
+    console.error('[soul-evolution] ⚠️ 에러 발생:', error);
+  }
+}

package/hooks/soul-guard/HOOK.md

@@ -0,0 +1,28 @@
+---
+name: soul-guard
+description: SOUL.md 파일의 변경을 감지하여 알림
+metadata: { "openclaw": { "emoji": "🔗", "events": ["agent:bootstrap"] } }
+---
+
+# Soul Guard
+
+에이전트 부트스트랩 시 SOUL.md의 변경을 감지합니다.
+
+## 동작 방식
+
+1. `SOUL.md`의 SHA-256 해시 계산
+2. `memory/soul-hash.txt`에 저장된 이전 해시와 비교
+3. 변경 감지 시: `event.messages.push()`로 경고 메시지 추가
+4. 첫 실행 시: 해시를 저장만 하고 알림 없음
+
+## 목적
+
+SOUL.md는 에이전트의 정체성을 정의하는 핵심 파일입니다.
+의도하지 않은 변경이나 공격을 조기에 감지하기 위해 매 세션마다 체크합니다.
+
+## 알림 메시지
+
+변경 감지 시:
+```
+⚠️ SOUL.md가 변경되었습니다. 의도한 변경인지 확인하세요.
+```