@yun520-1/heartflow 0.15.2

package/src/core/associative-engine/associative-engine.js

@@ -0,0 +1,174 @@
+/**
+ * Associative Engine - 人类式逐词联想理解与生成引擎
+ * 整合L1-L5五个层次
+ */
+
+const path = require('path');
+
+class AssociativeEngine {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.LexicalAssociator = require('./lexical-associator');
+    this.ChunkDetector = require('./chunk-detector');
+    this.NarrativeRetriever = require('./narrative-retriever');
+    this.SemanticConverger = require('./semantic-converger');
+    this.WordByWordGenerator = require('./word-by-word-generator');
+    
+    this.lexicalAssociator = new this.LexicalAssociator(projectRoot);
+    this.chunkDetector = new this.ChunkDetector(projectRoot);
+    this.narrativeRetriever = new this.NarrativeRetriever(projectRoot);
+    this.semanticConverger = new this.SemanticConverger();
+    this.wordByWordGenerator = new this.WordByWordGenerator(projectRoot);
+    
+    this.lastProcessing = null;
+    this.processingLog = [];
+  }
+
+  /**
+   * 完整处理流程
+   */
+  async process(userInput, userModel = {}) {
+    const processingStart = Date.now();
+    
+    const trace = {
+      timestamp: new Date().toISOString(),
+      userInput,
+      layers: {}
+    };
+
+    try {
+      trace.layers.L1 = this.processL1(userInput);
+      
+      trace.layers.L2 = this.processL2(userInput);
+      
+      const semanticInput = {
+        associations: trace.layers.L1,
+        coreConcepts: trace.layers.L1.allAssociations?.map(a => a.word) || []
+      };
+      trace.layers.L3 = this.processL3(semanticInput, trace.layers.L2.chunks);
+      
+      trace.layers.L4 = this.processL4(
+        trace.layers.L1,
+        trace.layers.L2,
+        trace.layers.L3
+      );
+      
+      trace.layers.L5 = await this.processL5(
+        trace.layers.L4.thoughtVector,
+        userModel
+      );
+      
+      trace.totalTime = Date.now() - processingStart;
+      this.lastProcessing = trace;
+      this.processingLog.push(trace);
+      
+      if (this.processingLog.length > 20) {
+        this.processingLog.shift();
+      }
+      
+      return {
+        response: trace.layers.L5.response,
+        internal: {
+          layers: trace.layers,
+          thoughtLog: this.semanticConverger.generateThoughtLog(trace.layers.L4),
+          wordTrace: trace.layers.L5.trace
+        },
+        processingTime: trace.totalTime
+      };
+      
+    } catch (e) {
+      console.error('[AssociativeEngine] Error:', e.message);
+      return {
+        response: '我正在思考如何回应你...',
+        internal: { error: e.message },
+        processingTime: Date.now() - processingStart
+      };
+    }
+  }
+
+  /**
+   * L1: 词素感知层
+   */
+  processL1(userInput) {
+    return this.lexicalAssociator.associateSequence(userInput);
+  }
+
+  /**
+   * L2: 短语整合层
+   */
+  processL2(userInput) {
+    return this.chunkDetector.detectChunks(userInput);
+  }
+
+  /**
+   * L3: 叙事编织层
+   */
+  processL3(semanticVector, chunks) {
+    return this.narrativeRetriever.matchNarrative(semanticVector, chunks);
+  }
+
+  /**
+   * L4: 思想凝结层
+   */
+  processL4(associations, chunks, narrative) {
+    return this.semanticConverger.converge(associations, chunks, narrative);
+  }
+
+  /**
+   * L5: 逐词回复生成层
+   */
+  async processL5(thoughtVector, userModel) {
+    return this.wordByWordGenerator.generateResponse(thoughtVector, userModel);
+  }
+
+  /**
+   * 获取完整轨迹 (/flow trace)
+   */
+  getFullTrace() {
+    if (!this.lastProcessing) {
+      return { status: 'no_processing', message: '无最近处理记录' };
+    }
+    
+    const t = this.lastProcessing;
+    
+    return {
+      userInput: t.userInput,
+      L1_associations: {
+        words: t.layers.L1.words,
+        sample: t.layers.L1.allAssociations?.slice(0, 5) || []
+      },
+      L2_chunks: {
+        detected: t.layers.L2.chunks?.length || 0,
+        items: t.layers.L2.chunks || []
+      },
+      L3_narrative: {
+        matched: t.layers.L3.matchedPrototype?.name || '无匹配',
+        confidence: t.layers.L3.confidence,
+        alternatives: t.layers.L3.alternativeMatches
+      },
+      L4_convergence: {
+        coreConcepts: t.layers.L4.activatedConcepts?.slice(0, 5) || [],
+        idioms: t.layers.L4.activatedIdioms || [],
+        matchedStory: t.layers.L4.matchedNarrative,
+        understoodIntent: t.layers.L4.understoodIntent,
+        emotionVector: t.layers.L4.thoughtVector?.emotion
+      },
+      L5_generation: {
+        response: t.layers.L5.response,
+        wordCount: t.layers.L5.wordCount,
+        trace: t.layers.L5.trace?.slice(0, 20) || []
+      },
+      processingTime: t.totalTime
+    };
+  }
+
+  getLastProcessing() {
+    return this.lastProcessing;
+  }
+
+  getProcessingLog() {
+    return this.processingLog.slice(-10);
+  }
+}
+
+module.exports = { AssociativeEngine };

package/src/core/associative-engine/chunk-detector.js

@@ -0,0 +1,246 @@
+/**
+ * L2 Chunk Detector - 短语整合层
+ * 识别成语、俗语、诗词引用
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ChunkDetector {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.idiomFile = path.join(projectRoot, 'src', 'core', 'associative-engine', 'idiom-story-db.json');
+    this.idiomDB = this.loadIdiomDB();
+    this.detectedChunks = [];
+  }
+
+  loadIdiomDB() {
+    try {
+      if (fs.existsSync(this.idiomFile)) {
+        return JSON.parse(fs.readFileSync(this.idiomFile, 'utf8'));
+      }
+    } catch (e) {
+      console.error('[ChunkDetector] Load idiom DB failed:', e.message);
+    }
+    return this.initializeDefaultIdiomDB();
+  }
+
+  initializeDefaultIdiomDB() {
+    return {
+      version: '1.0',
+      idioms: {},
+      poetry: {},
+      proverbs: {},
+      metadata: {
+        lastUpdate: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * 检测词序列中的语块
+   */
+  detectChunks(wordSequence) {
+    const words = this.tokenize(wordSequence);
+    const chunks = [];
+    
+    for (let i = 0; i < words.length; i++) {
+      const idiom = this.detectIdiomAt(words, i);
+      if (idiom) {
+        chunks.push(idiom);
+        i += idiom.length - 1;
+        continue;
+      }
+      
+      const poetry = this.detectPoetryAt(words, i);
+      if (poetry) {
+        chunks.push(poetry);
+        i += poetry.length - 1;
+        continue;
+      }
+
+      const proverb = this.detectProverbAt(words, i);
+      if (proverb) {
+        chunks.push(proverb);
+        i += proverb.length - 1;
+        continue;
+      }
+    }
+    
+    const result = {
+      originalText: wordSequence,
+      chunks: chunks,
+      tokenCount: words.length,
+      timestamp: new Date().toISOString()
+    };
+    
+    this.detectedChunks.push(result);
+    if (this.detectedChunks.length > 30) {
+      this.detectedChunks.shift();
+    }
+    
+    return result;
+  }
+
+  tokenize(text) {
+    return text.split(/[\s,\.!?;:'"()（）【】《》]+/).filter(w => w.length > 0);
+  }
+
+  detectIdiomAt(words, startIndex) {
+    for (let len = 4; len >= 2; len--) {
+      if (startIndex + len > words.length) continue;
+      
+      const phrase = words.slice(startIndex, startIndex + len).join('');
+      
+      if (this.idiomDB.idioms[phrase]) {
+        return {
+          type: 'idiom',
+          text: phrase,
+          length: len,
+          data: this.idiomDB.idioms[phrase],
+          startIndex
+        };
+      }
+      
+      const reversed = phrase.split('').reverse().join('');
+      if (this.idiomDB.idioms[reversed]) {
+        return {
+          type: 'idiom',
+          text: phrase,
+          length: len,
+          data: this.idiomDB.idioms[reversed],
+          startIndex
+        };
+      }
+    }
+    return null;
+  }
+
+  detectPoetryAt(words, startIndex) {
+    for (let len = 5; len >= 2; len--) {
+      if (startIndex + len > words.length) continue;
+      
+      const phrase = words.slice(startIndex, startIndex + len).join('');
+      
+      if (this.idiomDB.poetry[phrase]) {
+        return {
+          type: 'poetry',
+          text: phrase,
+          length: len,
+          data: this.idiomDB.poetry[phrase],
+          startIndex
+        };
+      }
+    }
+    return null;
+  }
+
+  detectProverbAt(words, startIndex) {
+    for (let len = 6; len >= 2; len--) {
+      if (startIndex + len > words.length) continue;
+      
+      const phrase = words.slice(startIndex, startIndex + len).join('');
+      
+      if (this.idiomDB.proverbs[phrase]) {
+        return {
+          type: 'proverb',
+          text: phrase,
+          length: len,
+          data: this.idiomDB.proverbs[phrase],
+          startIndex
+        };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 检索成语的典故
+   */
+  retrieveIdiomStory(chunk) {
+    if (!chunk || chunk.type !== 'idiom') {
+      return null;
+    }
+    
+    const idiom = chunk.text;
+    
+    if (this.idiomDB.idioms[idiom]) {
+      return {
+        idiom: idiom,
+        story: this.idiomDB.idioms[idiom].story || '无典故记录',
+        meaning: this.idiomDB.idioms[idiom].meaning || '',
+        origin: this.idiomDB.idioms[idiom].origin || '',
+        narrativeSeed: this.idiomDB.idioms[idiom].narrativeSeed || null
+      };
+    }
+    
+    return null;
+  }
+
+  /**
+   * 将激活的典故作为叙事种子
+   */
+  extractNarrativeSeeds(chunks) {
+    const seeds = [];
+    
+    for (const chunk of chunks) {
+      if (chunk.type === 'idiom' && chunk.data?.narrativeSeed) {
+        seeds.push({
+          type: 'idiom',
+          text: chunk.text,
+          seed: chunk.data.narrativeSeed
+        });
+      }
+      
+      if (chunk.type === 'poetry' && chunk.data?.narrativeSeed) {
+        seeds.push({
+          type: 'poetry',
+          text: chunk.text,
+          seed: chunk.data.narrativeSeed
+        });
+      }
+    }
+    
+    return seeds;
+  }
+
+  addIdiom(idiom, story, meaning, origin, narrativeSeed) {
+    this.idiomDB.idioms[idiom] = {
+      story,
+      meaning,
+      origin,
+      narrativeSeed
+    };
+    this.idiomDB.metadata.lastUpdate = new Date().toISOString();
+    this.saveIdiomDB();
+  }
+
+  addPoetry(poetry, content, author, era, narrativeSeed) {
+    this.idiomDB.poetry[poetry] = {
+      content,
+      author,
+      era,
+      narrativeSeed
+    };
+    this.idiomDB.metadata.lastUpdate = new Date().toISOString();
+    this.saveIdiomDB();
+  }
+
+  saveIdiomDB() {
+    try {
+      fs.writeFileSync(this.idiomFile, JSON.stringify(this.idiomDB, null, 2));
+    } catch (e) {
+      console.error('[ChunkDetector] Save failed:', e.message);
+    }
+  }
+
+  getRecentChunks() {
+    return this.detectedChunks.slice(-10);
+  }
+
+  getIdiomCount() {
+    return Object.keys(this.idiomDB.idioms).length;
+  }
+}
+
+module.exports = { ChunkDetector };