cogmem 3.6.2

package/dist/core/Metabolism.d.ts

@@ -0,0 +1,43 @@
+import type { Neuron } from '../types/index.js';
+import { MemoryGraph } from './MemoryGraph.js';
+import { EventStore } from '../store/EventStore.js';
+interface IVectorStore {
+    addVector(id: string, vector: number[]): void;
+    removePoint(id: string): void;
+    search(vector: number[], k: number): Array<{
+        id: string;
+        score: number;
+    }>;
+}
+export declare class Metabolism {
+    private memoryGraph;
+    private vectorStore;
+    private eventStore;
+    private isRunning;
+    private lastActivityTime;
+    private silentPeriod;
+    private metabolismInterval;
+    private batchSize;
+    constructor(memoryGraph: MemoryGraph, vectorStore?: IVectorStore, eventStore?: EventStore);
+    start(): Promise<void>;
+    stop(): void;
+    recordActivity(): void;
+    getHotMemories(): Neuron[];
+    setVectorStore(vs: IVectorStore): void;
+    setEventStore(es: EventStore): void;
+    private runMetabolismLoop;
+    /** 代谢循环 */
+    private performMetabolism;
+    /** 批量关联孤立神经元 */
+    private batchAssociateOrphans;
+    /** 批量强化（基于 repetitions） */
+    private batchReinforce;
+    /** 批量状态流转（SM-2 驱动） */
+    private batchTransitionStates;
+    private emitLifecycleEvent;
+    /** SM-2 能量计算: E = exp(-days / stability) * (1 + log10(repetitions + 1)) */
+    private calculateSM2Energy;
+    private sleep;
+}
+export {};
+//# sourceMappingURL=Metabolism.d.ts.map

package/dist/core/Metabolism.js

@@ -0,0 +1,196 @@
+// ============================================
+// Metabolism - 代谢器（后台自主循环）
+// 优化：SM-2 遗忘曲线 + stability/repetitions 驱动状态流转
+// ============================================
+import { logger } from '../utils/Logger.js';
+export class Metabolism {
+    memoryGraph;
+    vectorStore = null;
+    eventStore = null;
+    isRunning = false;
+    lastActivityTime = Date.now();
+    silentPeriod = 30000;
+    metabolismInterval = 60000;
+    batchSize = 1000;
+    constructor(memoryGraph, vectorStore, eventStore) {
+        this.memoryGraph = memoryGraph;
+        this.vectorStore = vectorStore || null;
+        this.eventStore = eventStore || null;
+    }
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.runMetabolismLoop();
+    }
+    stop() { this.isRunning = false; }
+    recordActivity() { this.lastActivityTime = Date.now(); }
+    getHotMemories() {
+        return this.memoryGraph.getAllNeurons().filter(n => n.metadata.status === 'active');
+    }
+    setVectorStore(vs) { this.vectorStore = vs; }
+    setEventStore(es) { this.eventStore = es; }
+    async runMetabolismLoop() {
+        while (this.isRunning) {
+            const elapsed = Date.now() - this.lastActivityTime;
+            if (elapsed >= this.silentPeriod) {
+                await this.performMetabolism();
+            }
+            await this.sleep(this.metabolismInterval);
+        }
+    }
+    /** 代谢循环 */
+    async performMetabolism() {
+        logger.info('Metabolism: performing batch metabolism cycle');
+        this.memoryGraph.transaction(() => {
+            this.batchAssociateOrphans();
+            this.batchReinforce();
+            this.batchTransitionStates();
+        });
+    }
+    /** 批量关联孤立神经元 */
+    batchAssociateOrphans() {
+        const orphanIds = this.memoryGraph.getOrphanNeuronIds(this.batchSize);
+        for (const id of orphanIds) {
+            const neuron = this.memoryGraph.getNeuron(id);
+            if (!neuron)
+                continue;
+            const similar = this.memoryGraph.findSimilarNeurons(neuron.coordinates.V, 5);
+            for (const { id, score } of similar) {
+                if (score > 0.8 && !this.memoryGraph.hasSynapse(neuron.id, id)) {
+                    this.memoryGraph.addSynapse(neuron.id, { targetId: id, type: 'Similar', weight: 0.1 });
+                }
+            }
+        }
+    }
+    /** 批量强化（基于 repetitions） */
+    batchReinforce() {
+        const thresholds = [10, 50, 100, 200, 500, 1000];
+        const neuronIds = this.memoryGraph.getNeuronIdsForReinforcement(this.batchSize);
+        for (const id of neuronIds) {
+            const neuron = this.memoryGraph.getNeuron(id);
+            if (!neuron)
+                continue;
+            const reps = neuron.metadata.repetitions || 0;
+            const reached = thresholds.find(t => reps >= t);
+            if (!reached)
+                continue;
+            for (const synapse of neuron.synapses) {
+                const newWeight = Math.min(1.0, synapse.weight + 0.1);
+                if (Math.abs(newWeight - synapse.weight) > 0.05) {
+                    this.memoryGraph.addSynapse(neuron.id, { ...synapse, weight: newWeight });
+                }
+            }
+        }
+    }
+    /** 批量状态流转（SM-2 驱动） */
+    batchTransitionStates() {
+        const neuronIds = this.memoryGraph.getNeuronIdsForTransition(this.batchSize);
+        let hot = 0, cold = 0, archived = 0;
+        for (const id of neuronIds) {
+            const neuron = this.memoryGraph.getNeuron(id);
+            if (!neuron)
+                continue;
+            if (neuron.metadata.isPinned) {
+                const previousStatus = neuron.metadata.status || 'active';
+                if (previousStatus !== 'active') {
+                    this.memoryGraph.updateNeuronStatus(neuron.id, 'active');
+                    if (this.vectorStore && previousStatus === 'archived' && neuron.coordinates.V.length > 0) {
+                        try {
+                            this.vectorStore.addVector(neuron.id, neuron.coordinates.V);
+                        }
+                        catch { }
+                    }
+                    this.emitLifecycleEvent(neuron, previousStatus, 'active', 1.0);
+                }
+                hot++;
+                continue;
+            }
+            const stability = neuron.metadata.stability || 1.0;
+            const repetitions = neuron.metadata.repetitions || 0;
+            const lastActivated = neuron.metadata.lastActivated || neuron.metadata.createdAt;
+            const elapsedDays = (Date.now() - lastActivated) / (1000 * 60 * 60 * 24);
+            // SM-2 计算当前能量
+            const currentEnergy = this.calculateSM2Energy(stability, repetitions, elapsedDays);
+            // 状态决策
+            let newStatus;
+            if (currentEnergy > 0.8 || repetitions >= 100) {
+                newStatus = 'active';
+                hot++;
+            }
+            else if (currentEnergy >= 0.3) {
+                newStatus = 'cold';
+                cold++;
+            }
+            else {
+                newStatus = 'archived';
+                archived++;
+            }
+            const previousStatus = neuron.metadata.status || 'active';
+            if (newStatus !== previousStatus) {
+                this.memoryGraph.updateNeuronStatus(neuron.id, newStatus);
+                if (this.vectorStore) {
+                    try {
+                        if (newStatus === 'archived') {
+                            this.vectorStore.removePoint(neuron.id);
+                        }
+                        else if (previousStatus === 'archived' && neuron.coordinates.V.length > 0) {
+                            this.vectorStore.addVector(neuron.id, neuron.coordinates.V);
+                        }
+                    }
+                    catch { }
+                }
+                this.emitLifecycleEvent(neuron, previousStatus, newStatus, currentEnergy);
+            }
+        }
+        logger.info(`Metabolism: Hot=${hot}, Cold=${cold}, Archived=${archived}`);
+    }
+    emitLifecycleEvent(neuron, previousStatus, nextStatus, currentEnergy) {
+        if (!this.eventStore)
+            return;
+        if (nextStatus === 'archived') {
+            this.eventStore.append({
+                streamId: neuron.id,
+                streamType: 'neuron',
+                eventType: 'ARCHIVED',
+                projectId: neuron.metadata.projectId,
+                sourceNeuronId: neuron.id,
+                payload: {
+                    neuronId: neuron.id,
+                    previousStatus,
+                    nextStatus,
+                    currentEnergy,
+                    repetitions: neuron.metadata.repetitions || 0,
+                    stability: neuron.metadata.stability || 1.0
+                }
+            });
+            return;
+        }
+        if (previousStatus === 'archived' && (nextStatus === 'cold' || nextStatus === 'active')) {
+            this.eventStore.append({
+                streamId: neuron.id,
+                streamType: 'neuron',
+                eventType: 'RESTORED',
+                projectId: neuron.metadata.projectId,
+                sourceNeuronId: neuron.id,
+                payload: {
+                    neuronId: neuron.id,
+                    previousStatus,
+                    nextStatus,
+                    currentEnergy,
+                    repetitions: neuron.metadata.repetitions || 0,
+                    stability: neuron.metadata.stability || 1.0
+                }
+            });
+        }
+    }
+    /** SM-2 能量计算: E = exp(-days / stability) * (1 + log10(repetitions + 1)) */
+    calculateSM2Energy(stability, repetitions, elapsedDays) {
+        const forgettingFactor = Math.exp(-elapsedDays / stability);
+        const reinforcementFactor = 1 + Math.log10(repetitions + 1);
+        return Math.min(1.0, forgettingFactor * reinforcementFactor);
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}

package/dist/core/Neuron.d.ts

@@ -0,0 +1,20 @@
+import type { Neuron, NeuronMetadata, NeuronCoordinates, Synapse } from '../types/index.js';
+export declare class NeuronFactory {
+    /**
+     * 创建新神经元
+     */
+    static create(content: string, prevHash: string, coordinates: NeuronCoordinates, metadata: NeuronMetadata, synapses?: Synapse[]): Neuron;
+    /**
+     * 验证神经元完整性
+     */
+    static verify(neuron: Neuron): boolean;
+    /**
+     * 标记神经元为可疑状态
+     */
+    static markSuspect(neuron: Neuron): Neuron;
+    /**
+     * 激活神经元（更新 lastActivated 时间戳）
+     */
+    static activate(neuron: Neuron): Neuron;
+}
+//# sourceMappingURL=Neuron.d.ts.map

package/dist/core/Neuron.js

@@ -0,0 +1,51 @@
+// ============================================
+// 神经元类 - 核心数据结构
+// ============================================
+import { HashUtils } from '../utils/hash.js';
+export class NeuronFactory {
+    /**
+     * 创建新神经元
+     */
+    static create(content, prevHash, coordinates, metadata, synapses = []) {
+        const selfHash = HashUtils.computeSelfHash(content, coordinates.T, coordinates.S);
+        return {
+            id: `neuron-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            content,
+            prev_hash: prevHash,
+            self_hash: selfHash,
+            coordinates,
+            synapses,
+            metadata
+        };
+    }
+    /**
+     * 验证神经元完整性
+     */
+    static verify(neuron) {
+        return HashUtils.verifyNeuronHash(neuron);
+    }
+    /**
+     * 标记神经元为可疑状态
+     */
+    static markSuspect(neuron) {
+        return {
+            ...neuron,
+            metadata: {
+                ...neuron.metadata,
+                status: 'suspect'
+            }
+        };
+    }
+    /**
+     * 激活神经元（更新 lastActivated 时间戳）
+     */
+    static activate(neuron) {
+        return {
+            ...neuron,
+            metadata: {
+                ...neuron.metadata,
+                lastActivated: Date.now()
+            }
+        };
+    }
+}

package/dist/core/QueryClassifier.d.ts

@@ -0,0 +1,36 @@
+import type { QueryOptions } from '../types/index.js';
+import { BrainMode } from '../types/index.js';
+export type QueryType = 'HARD' | 'STANDARD' | 'FUZZY';
+export interface QueryClassification {
+    type: QueryType;
+    mode: BrainMode;
+    confidence: number;
+    reasoning: string;
+}
+export declare class QueryClassifier {
+    /**
+     * 分类查询
+     */
+    static classify(query: string, options?: QueryOptions): QueryClassification;
+    /**
+     * 判断是否是 HARD 查询
+     */
+    private static isHardQuery;
+    /**
+     * 判断是否是 FUZZY 查询
+     */
+    private static isFuzzyQuery;
+    /**
+     * 获取当前降级模式
+     */
+    static getCurrentMode(): BrainMode;
+    /**
+     * 获取降级状态
+     */
+    static getDegradationState(): {
+        mode: BrainMode;
+        trigger: string;
+        timestamp: number;
+    };
+}
+//# sourceMappingURL=QueryClassifier.d.ts.map

package/dist/core/QueryClassifier.js

@@ -0,0 +1,161 @@
+// ============================================
+// 查询分类器 - 智能路由
+// ============================================
+import { BrainMode } from '../types/index.js';
+import { config } from '../utils/Config.js';
+export class QueryClassifier {
+    /**
+     * 分类查询
+     */
+    static classify(query, options) {
+        // 优先检查是否是 FUZZY 查询（自然语言）
+        if (this.isFuzzyQuery(query)) {
+            return {
+                type: 'FUZZY',
+                mode: BrainMode.FULL,
+                confidence: 0.8,
+                reasoning: 'Natural language query - requires LLM assistance'
+            };
+        }
+        // 检查是否是 HARD 查询（代码片段、文件路径等）
+        if (this.isHardQuery(query)) {
+            return {
+                type: 'HARD',
+                mode: BrainMode.FULL,
+                confidence: 0.9,
+                reasoning: 'Contains code patterns or file paths - requires exact matching'
+            };
+        }
+        // 默认为 STANDARD 查询
+        return {
+            type: 'STANDARD',
+            mode: BrainMode.FULL,
+            confidence: 0.7,
+            reasoning: 'Standard semantic search'
+        };
+    }
+    /**
+     * 判断是否是 HARD 查询
+     */
+    static isHardQuery(query) {
+        // 检查代码模式
+        const codePatterns = [
+            /function\s+\w+/,
+            /class\s+\w+/,
+            /import\s+.*from/,
+            /export\s+(default\s+)?/,
+            /const\s+\w+\s*=/,
+            /let\s+\w+\s*=/,
+            /=>\s*{/,
+            /\.\w+\(/,
+            /\/\/.*TODO/,
+            /\/\/.*FIXME/
+        ];
+        for (const pattern of codePatterns) {
+            if (pattern.test(query)) {
+                return true;
+            }
+        }
+        // 检查文件路径
+        if (/\/[\w\-./]+/.test(query)) {
+            return true;
+        }
+        // 检查特定关键词（更严格的匹配）
+        const hardKeywords = [
+            /\bfix\s+(the|a|an)?\s*\w+/i,
+            /\bbug\s+(in|with|for)\s*/i,
+            /\berror\s+(handling|message|code)/i,
+            /\bexception\s+(handling|throwing)/i,
+            /\bthrow\s+new\s+/i,
+            /\bimplement\s+(the|a|an)?\s*\w+\s+(function|method|class)/i,
+            /\brefactor\s+(the|a|an)?\s*\w+/i,
+            /\boptimize\s+(the|a|an)?\s*\w+/i,
+            /\bdebug\s+(the|a|an)?\s*\w+/i
+        ];
+        for (const keyword of hardKeywords) {
+            if (keyword.test(query)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 判断是否是 FUZZY 查询
+     */
+    static isFuzzyQuery(query) {
+        // 检查模糊时间表达
+        const fuzzyTimePatterns = [
+            /recent/i,
+            /lately/i,
+            /last\s+(week|month|year)/i,
+            /a\s+few\s+(days|weeks|months)/i,
+            /yesterday/i,
+            /today/i
+        ];
+        for (const pattern of fuzzyTimePatterns) {
+            if (pattern.test(query)) {
+                return true;
+            }
+        }
+        // 检查模糊空间表达
+        const fuzzySpatialPatterns = [
+            /nearby/i,
+            /around/i,
+            /close\s+to/i,
+            /in\s+the\s+area/i
+        ];
+        for (const pattern of fuzzySpatialPatterns) {
+            if (pattern.test(query)) {
+                return true;
+            }
+        }
+        // 检查自然语言特征（优先级更高）
+        const naturalLanguagePatterns = [
+            /what\s+(is|was|are|were)/i,
+            /how\s+(do|does|did|can|could|should|would)/i,
+            /why\s+(do|does|did|is|was|are|were)/i,
+            /tell\s+me\s+about/i,
+            /show\s+me/i,
+            /find\s+(something|anything)/i,
+            /explain/i,
+            /describe/i,
+            /help\s+me/i
+        ];
+        for (const pattern of naturalLanguagePatterns) {
+            if (pattern.test(query)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取当前降级模式
+     */
+    static getCurrentMode() {
+        const mem = process.memoryUsage().heapUsed / 1024 / 1024;
+        // 如果内存超过阈值，强制进入 TEXT_ONLY 模式
+        if (mem > config.degradation.memoryThresholdMB) {
+            return BrainMode.TEXT_ONLY;
+        }
+        // 正常模式
+        return BrainMode.FULL;
+    }
+    /**
+     * 获取降级状态
+     */
+    static getDegradationState() {
+        const mode = this.getCurrentMode();
+        let trigger = 'normal';
+        if (mode === 'TEXT_ONLY') {
+            trigger = 'high_memory_usage';
+        }
+        else if (mode === 'NO_SYNAPSE') {
+            trigger = 'slow_inference';
+        }
+        return {
+            mode,
+            trigger,
+            timestamp: Date.now()
+        };
+    }
+}

package/dist/core/Reflection.d.ts

@@ -0,0 +1,42 @@
+import type { Neuron, MemoryAnchor } from '../types/index.js';
+import { MemoryGraph } from './MemoryGraph.js';
+export declare class Reflection {
+    private memoryGraph;
+    private activationLog;
+    private coOccurrenceMap;
+    constructor(memoryGraph: MemoryGraph);
+    /** 每日权重更新 */
+    dailyWeightUpdate(): Promise<void>;
+    /** 动态触发：频繁激活 → 短期转长期 + 增加 stability */
+    onNeuronActivated(neuronId: string): void;
+    /** SM-2 遗忘曲线: CurrentWeight = BaseWeight * exp(-elapsedTime_in_days / stability) */
+    private applySM2Forgetting;
+    /** 检测并创建 Overrides 突触 */
+    detectAndCreateOverrides(newNeuron: Neuron, vectorSearchFn?: (vector: number[], k: number) => Array<{
+        id: string;
+        score: number;
+    }>): void;
+    /** 查找冲突的旧记忆（向量检索 + 极性碰撞） */
+    findConflictingNeurons(newNeuron: Neuron, vectorSearchFn?: (vector: number[], k: number) => Array<{
+        id: string;
+        score: number;
+    }>): Neuron[];
+    /** 极性碰撞检测 */
+    private checkPolarityCollision;
+    private findCoOccurrences;
+    private recordCoOccurrence;
+    private boostSynapses;
+    private getSynapse;
+    private updateSynapse;
+    createAnchor(neuronIds: string[], projectId?: string): Promise<MemoryAnchor>;
+    getActivationStats(): {
+        totalActivations: number;
+        activeNeurons: number;
+        topActivated: {
+            id: string;
+            count: number;
+        }[];
+    };
+    cleanupOldActivations(maxAge?: number): void;
+}
+//# sourceMappingURL=Reflection.d.ts.map