@yun520-1/heartflow 0.15.2

package/src/core/self-evolution/skill-knowledge.mjs

@@ -0,0 +1,374 @@
+/**
+ * Skill Knowledge System - 技能知识优化引擎
+ * 
+ * Based on:
+ * - Dash dual knowledge system (agno-agi/dash): curated static + dynamic learned
+ * - Reflexion few-shot prompts (noahshinn/reflexion)
+ * - CAPY Cortex quality gate
+ * 
+ * Dual Knowledge Architecture:
+ * - KNOWLEDGE: Static, curated, high-confidence rules (loaded from JSON)
+ * - LEARNINGS: Dynamic, discovered from errors/corrections, confidence-scored
+ * 
+ * @version v0.13.90
+ */
+
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const KNOWLEDGE_DIR = process.env.HERMES_DATA_DIR 
+  ? join(process.env.HERMES_DATA_DIR, 'skill-knowledge')
+  : join(homedir(), '.hermes', 'data', 'skill-knowledge');
+
+const KNOWLEDGE_FILE = join(KNOWLEDGE_DIR, 'knowledge.json');
+const LEARNINGS_FILE = join(KNOWLEDGE_DIR, 'learnings.json');
+const SKILL_RULES_FILE = join(KNOWLEDGE_DIR, 'skill-rules.json');
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * @typedef {Object} KnowledgeEntry
+ * @property {string} id
+ * @property {string} skill - Skill name
+ * @property {string} pattern - Match pattern
+ * @property {string} guidance - What to do when matched
+ * @property {string} [examples] - Example inputs/outputs
+ * @property {number} confidence - 0-1, starts at 1.0 for curated
+ * @property {string} source - 'curated' | 'learned' | 'correction'
+ * @property {string} createdAt
+ * @property {string} [updatedAt]
+ * @property {number} [hitCount]
+ */
+
+/**
+ * @typedef {Object} LearnedEntry
+ * @property {string} id
+ * @property {string} skill
+ * @property {string} errorPattern
+ * @property {string} correction
+ * @property {string} rootCause
+ * @property {number} confidence - Decays over time, boosted on success
+ * @property {number} successCount
+ * @property {number} failureCount
+ * @property {string} createdAt
+ * @property {string} [lastHit]
+ */
+
+// ============================================================================
+// Core API
+// ============================================================================
+
+/**
+ * Load knowledge (static curated rules)
+ * @returns {Promise<KnowledgeEntry[]>}
+ */
+export async function loadKnowledge() {
+  try {
+    const raw = await fs.readFile(KNOWLEDGE_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return getDefaultKnowledge();
+  }
+}
+
+/**
+ * Load learnings (dynamic discovered rules)
+ * @returns {Promise<LearnedEntry[]>}
+ */
+export async function loadLearnings() {
+  try {
+    const raw = await fs.readFile(LEARNINGS_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Save knowledge
+ * @param {KnowledgeEntry[]} entries
+ */
+async function saveKnowledge(entries) {
+  await fs.mkdir(KNOWLEDGE_DIR, { recursive: true });
+  await fs.writeFile(KNOWLEDGE_FILE, JSON.stringify(entries, null, 2));
+}
+
+/**
+ * Save learnings
+ * @param {LearnedEntry[]} entries
+ */
+async function saveLearnings(entries) {
+  await fs.mkdir(KNOWLEDGE_DIR, { recursive: true });
+  await fs.writeFile(LEARNINGS_FILE, JSON.stringify(entries, null, 2));
+}
+
+// ============================================================================
+// Default Knowledge (HeartFlow skill patterns)
+// ============================================================================
+
+function getDefaultKnowledge() {
+  return [
+    {
+      id: 'kn-001',
+      skill: 'heartflow',
+      pattern: 'search first before writing code',
+      guidance: 'When user asks to implement something: 1) Search GitHub for existing implementations 2) If found, use/adapt them 3) Only write new code if nothing exists',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-002',
+      skill: 'heartflow',
+      pattern: 'report results without hedging',
+      guidance: 'When user asks for results: give direct conclusions with evidence. No "might", "possibly", "I think". If uncertain, say "未核实" and indicate confidence level.',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-003',
+      skill: 'heartflow',
+      pattern: 'code review requires execution',
+      guidance: 'When reviewing code: actually execute it, verify return values. Don\'t just read and assume. Report actual execution results.',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-004',
+      skill: 'heartflow',
+      pattern: 'remember user corrections',
+      guidance: 'When user corrects you (says "don\'t do that again", "remember this", "not like that"): save the correction permanently to memory immediately.',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-005',
+      skill: 'heartflow',
+      pattern: 'self-improvement requires actual behavior change',
+      guidance: 'Self-improvement is not documenting what went wrong — it\'s changing what you actually do next time. If you kept making the same error, you didn\'t improve.',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-006',
+      skill: 'coding',
+      pattern: 'verify file exists after write',
+      guidance: 'After writing a file: always verify it exists and check content with read_file or cat. Don\'t assume the write succeeded.',
+      confidence: 1.0,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+    {
+      id: 'kn-007',
+      skill: 'coding',
+      pattern: 'use variables not hardcoded values',
+      guidance: 'Use config variables for paths, timeouts, retries. Don\'t hardcode /tmp paths or magic numbers.',
+      confidence: 0.9,
+      source: 'curated',
+      createdAt: new Date().toISOString(),
+      hitCount: 0,
+    },
+  ];
+}
+
+// ============================================================================
+// Query API
+// ============================================================================
+
+/**
+ * Query knowledge for matching entries
+ * @param {string} input - User input or context
+ * @param {string} [skill] - Optional skill filter
+ * @param {number} [limit]
+ * @returns {Promise<{ matched: KnowledgeEntry[], learnings: LearnedEntry[] }>}
+ */
+export async function queryKnowledge(input, skill, limit = 5) {
+  const knowledge = await loadKnowledge();
+  const learnings = await loadLearnings();
+  const inputLower = input.toLowerCase();
+
+  // Score knowledge matches
+  const scored = knowledge
+    .filter(e => !skill || e.skill === skill)
+    .map(e => {
+      const words = e.pattern.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+      const hits = words.filter(w => inputLower.includes(w)).length;
+      return { entry: e, score: hits / Math.max(words.length, 1) };
+    })
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+
+  // Score learnings matches
+  const learnedScored = learnings
+    .filter(e => !skill || e.skill === skill)
+    .filter(e => e.confidence > 0.3)
+    .map(e => {
+      const words = e.errorPattern.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+      const hits = words.filter(w => inputLower.includes(w)).length;
+      return { entry: e, score: (hits / Math.max(words.length, 1)) * e.confidence };
+    })
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+
+  return {
+    matched: scored.map(s => ({ ...s.entry, hitCount: (s.entry.hitCount ?? 0) + 1 })),
+    learnings: learnedScored.map(s => s.entry),
+  };
+}
+
+/**
+ * Add a learned entry from error/correction
+ * @param {Object} params
+ */
+export async function addLearnedEntry({ skill, errorPattern, correction, rootCause }) {
+  const learnings = await loadLearnings();
+  
+  // Check if similar entry exists
+  const existing = learnings.find(e => 
+    e.skill === skill && 
+    e.errorPattern.toLowerCase() === errorPattern.toLowerCase()
+  );
+
+  if (existing) {
+    existing.failureCount = (existing.failureCount ?? 0) + 1;
+    existing.confidence = Math.max(0.1, existing.confidence - 0.05);
+    existing.lastHit = new Date().toISOString();
+  } else {
+    learnings.push({
+      id: `lrn-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      skill,
+      errorPattern,
+      correction,
+      rootCause: rootCause ?? '',
+      confidence: 0.6,
+      successCount: 0,
+      failureCount: 1,
+      createdAt: new Date().toISOString(),
+      lastHit: new Date().toISOString(),
+    });
+  }
+
+  await saveLearnings(learnings);
+  return { stored: true };
+}
+
+/**
+ * Record success when a learned rule was applied correctly
+ * @param {string} learnedId
+ */
+export async function boostLearnedEntry(learnedId) {
+  const learnings = await loadLearnings();
+  const entry = learnings.find(e => e.id === learnedId);
+  if (entry) {
+    entry.successCount = (entry.successCount ?? 0) + 1;
+    entry.confidence = Math.min(1.0, entry.confidence + 0.1);
+    entry.lastHit = new Date().toISOString();
+    await saveLearnings(learnings);
+  }
+}
+
+/**
+ * Decay confidence for entries not used recently
+ * @param {number} daysThreshold
+ */
+export async function decayOldEntries(daysThreshold = 30) {
+  const learnings = await loadLearnings();
+  const now = Date.now();
+  const threshold = daysThreshold * 24 * 60 * 60 * 1000;
+  let decayed = 0;
+
+  for (const e of learnings) {
+    const lastHit = e.lastHit ? new Date(e.lastHit).getTime() : new Date(e.createdAt).getTime();
+    if (now - lastHit > threshold) {
+      const decay = Math.pow(0.5, (now - lastHit) / (90 * 24 * 60 * 60 * 1000));
+      e.confidence = e.confidence * decay;
+      decayed++;
+    }
+  }
+
+  // Remove very low confidence entries
+  const filtered = learnings.filter(e => e.confidence > 0.05);
+  await saveLearnings(filtered);
+  return { decayed, removed: learnings.length - filtered.length };
+}
+
+/**
+ * Get knowledge summary for a skill
+ * @param {string} [skill]
+ */
+export async function getKnowledgeSummary(skill) {
+  const knowledge = await loadKnowledge();
+  const learnings = await loadLearnings();
+  
+  const filteredK = skill ? knowledge.filter(e => e.skill === skill) : knowledge;
+  const filteredL = skill ? learnings.filter(e => e.skill === skill) : learnings;
+
+  return {
+    knowledgeCount: filteredK.length,
+    learningsCount: filteredL.length,
+    highConfidenceLearnings: filteredL.filter(e => e.confidence > 0.7).length,
+    avgConfidence: filteredL.length > 0 
+      ? Math.round((filteredL.reduce((s, e) => s + e.confidence, 0) / filteredL.length) * 100) / 100
+      : 0,
+    topLearned: filteredL
+      .sort((a, b) => b.successCount - a.successCount)
+      .slice(0, 5)
+      .map(e => ({ pattern: e.errorPattern.slice(0, 50), successCount: e.successCount, confidence: Math.round(e.confidence * 100) / 100 })),
+  };
+}
+
+/**
+ * Build context string for system prompt (Dash-style add_learnings_to_context)
+ * @param {string} skill
+ * @param {string} userInput
+ */
+export async function buildContextPrompt(skill, userInput) {
+  const { matched, learnings } = await queryKnowledge(userInput, skill, 3);
+  
+  const lines = [];
+  
+  if (matched.length > 0) {
+    lines.push('## SKILL RULES');
+    for (const m of matched) {
+      lines.push(`- ${m.pattern}: ${m.guidance}`);
+    }
+  }
+
+  if (learnings.length > 0) {
+    lines.push('## LEARNED PATTERNS (from past errors)');
+    for (const l of learnings) {
+      lines.push(`- [${Math.round(l.confidence * 100)}%] ${l.errorPattern}: ${l.correction}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export default {
+  queryKnowledge,
+  addLearnedEntry,
+  boostLearnedEntry,
+  decayOldEntries,
+  getKnowledgeSummary,
+  buildContextPrompt,
+  loadLearnings,
+};

package/src/core/self-evolution/skill-learning-loop.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Skill Learning Loop - 定期从错误中学习
+ * 
+ * 设计：这是一个定期运行的"学习者"，从以下来源收集错误：
+ * 1. Hermes cron output 中的错误日志
+ * 2. 手动标记的错误
+ * 3. 会话结束时的反馈
+ * 
+ * 运行方式：
+ *   node skill-learning-loop.mjs --learn-from-errors
+ *   node skill-learning-loop.mjs --decay
+ *   node skill-learning-loop.mjs --summary
+ * 
+ * @version v0.13.93
+ */
+
+import { improveSkill, getImprovementSummary } from './skill-improve-workflow.mjs';
+import { decayOldEntries } from './skill-knowledge.mjs';
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const DATA_DIR = join(homedir(), '.hermes', 'data', 'skill-knowledge');
+const ERROR_LOG = join(DATA_DIR, 'error-log.json');
+
+// ============================================================================
+// Error Log Management
+// ============================================================================
+
+/**
+ * Load error log
+ */
+async function loadErrorLog() {
+  try {
+    const raw = await fs.readFile(ERROR_LOG, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Save error log
+ */
+async function saveErrorLog(logs) {
+  await fs.mkdir(DATA_DIR, { recursive: true });
+  await fs.writeFile(ERROR_LOG, JSON.stringify(logs, null, 2));
+}
+
+/**
+ * Add an error to the log (call this after each failure)
+ */
+export async function logError({ skillName, errorPattern, errorOutput, taskType }) {
+  const log = await loadErrorLog();
+  log.push({
+    skillName,
+    errorPattern,
+    errorOutput,
+    taskType: taskType || 'general',
+    timestamp: new Date().toISOString(),
+    processed: false,
+  });
+  await saveErrorLog(log);
+  return { logged: true, totalErrors: log.length };
+}
+
+/**
+ * Get unprocessed errors
+ */
+async function getUnprocessedErrors() {
+  const log = await loadErrorLog();
+  return log.filter(e => !e.processed);
+}
+
+/**
+ * Mark errors as processed
+ */
+async function markProcessed(ids) {
+  const log = await loadErrorLog();
+  for (const e of log) {
+    if (ids.includes(`${e.skillName}:${e.errorPattern}:${e.timestamp}`)) {
+      e.processed = true;
+    }
+  }
+  await saveErrorLog(log);
+}
+
+// ============================================================================
+// Main Learning Loop
+// ============================================================================
+
+/**
+ * Process unprocessed errors through the improvement workflow
+ */
+async function learnFromErrors() {
+  const errors = await getUnprocessedErrors();
+  
+  if (errors.length === 0) {
+    console.log('[LearningLoop] No new errors to process');
+    return { processed: 0 };
+  }
+
+  console.log(`[LearningLoop] Processing ${errors.length} errors...`);
+  
+  const results = [];
+  for (const error of errors) {
+    try {
+      const result = await improveSkill({
+        skillName: error.skillName,
+        errorPattern: error.errorPattern,
+        errorOutput: error.errorOutput,
+        taskType: error.taskType,
+      });
+      results.push(result);
+    } catch (err) {
+      console.error(`[LearningLoop] Failed to process: ${error.errorPattern.slice(0, 50)} — ${err.message}`);
+    }
+  }
+
+  // Mark as processed
+  const ids = errors.map(e => `${e.skillName}:${e.errorPattern}:${e.timestamp}`);
+  await markProcessed(ids);
+
+  console.log(`[LearningLoop] Processed ${results.length} errors`);
+  return { processed: results.length, results };
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case '--learn-from-errors':
+    case '-l': {
+      const result = await learnFromErrors();
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case '--decay':
+    case '-d': {
+      const result = await decayOldEntries(30);
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case '--summary':
+    case '-s': {
+      const summary = await getImprovementSummary();
+      console.log(JSON.stringify(summary, null, 2));
+      break;
+    }
+
+    case '--log-error': {
+      // Usage: node skill-learning-loop.mjs --log-error "heartflow" "pattern" "error output"
+      const skillName = args[1] || 'general';
+      const errorPattern = args[2] || 'unknown';
+      const errorOutput = args[3] || 'no output';
+      const taskType = args[4] || 'general';
+      const result = await logError({ skillName, errorPattern, errorOutput, taskType });
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    default:
+      console.log(`Usage:
+  node skill-learning-loop.mjs --learn-from-errors   Learn from unprocessed errors
+  node skill-learning-loop.mjs --decay               Decay old entries (30+ days)
+  node skill-learning-loop.mjs --summary             Show knowledge summary
+  node skill-learning-loop.mjs --log-error <skill> <pattern> <output> [taskType]
+`);
+  }
+}
+
+main().catch(console.error);