@yun520-1/heartflow 0.15.2 → 0.16.0

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

@@ -1,174 +0,0 @@
-/**
- * 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

@@ -1,246 +0,0 @@
-/**
- * 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 };