cogmem 3.6.2

package/dist/context/ContextCortex.js

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+const INTENT_LAYERS = {
+    greeting: [],
+    short_followup: ['session_state', 'turn_bridge'],
+    exact_quote: ['raw_source', 'graph', 'belief'],
+    decision_history: ['temporal', 'belief', 'raw_source', 'graph'],
+    preference_lookup: ['belief', 'raw_source', 'graph'],
+    project_status: ['belief', 'temporal', 'graph', 'raw_source'],
+    debugging: ['graph', 'raw_source', 'belief', 'temporal'],
+    general_memory: ['belief', 'graph', 'temporal', 'raw_source', 'vector'],
+};
+export class ContextCortex {
+    db;
+    constructor(db) {
+        this.db = db;
+        if (db)
+            this.initializeSchema();
+    }
+    classifyIntent(query) {
+        const text = query.trim().toLowerCase();
+        if (/^(hi|hello|hey|你好|您好|早上好|晚上好|嗨)[!！。. ]*$/.test(text))
+            return 'greeting';
+        if (/^(继续|接着|然后呢|上面那个|刚才说的|这个呢|continue|go on|and then)[?？!！。. ]*$/.test(text))
+            return 'short_followup';
+        if (/原话|逐字|怎么说的|完整对话|exact quote|verbatim|word for word/.test(text))
+            return 'exact_quote';
+        if (/为什么.*(改|变|推翻)|何时|什么时候|之前.*决定|decision.*(change|history)|why.*change|timeline|历史/.test(text))
+            return 'decision_history';
+        if (/偏好|喜欢|不喜欢|边界|习惯|preference|prefer|boundary/.test(text))
+            return 'preference_lookup';
+        if (/项目.*(状态|进度|当前)|release status|project status|current state/.test(text))
+            return 'project_status';
+        if (/报错|错误|调试|根因|bug|debug|error|failure|root cause/.test(text))
+            return 'debugging';
+        return 'general_memory';
+    }
+    plan(input) {
+        const intent = this.classifyIntent(input.query);
+        const requestedRatio = input.maxMemoryRatio ?? input.strategy?.maxMemoryRatio ?? 0.25;
+        const ratio = Math.max(0, Math.min(0.3, requestedRatio, input.strategy?.maxMemoryRatio ?? 0.3));
+        const budgetTokens = Math.max(0, Math.floor(Math.max(0, input.availableTokens) * ratio));
+        const intentLayers = input.topicRelation === 'new'
+            ? INTENT_LAYERS[intent].filter((layer) => layer !== 'session_state' && layer !== 'turn_bridge')
+            : INTENT_LAYERS[intent];
+        const strategyLayers = input.strategy
+            ? [...input.strategy.primaryLayers, ...input.strategy.secondaryLayers]
+            : intentLayers;
+        const allowedLayers = strategyLayers.filter((layer) => intentLayers.includes(layer));
+        const selected = [];
+        const selectedReceipt = [];
+        const suppressed = [];
+        const seen = new Set();
+        let usedTokens = 0;
+        const eligible = [];
+        for (const candidate of input.candidates) {
+            const hardReason = this.hardSuppressionReason(candidate, input, intent);
+            if (hardReason) {
+                suppressed.push({ id: candidate.id, layer: candidate.layer, reason: hardReason });
+                continue;
+            }
+            if (intent === 'greeting') {
+                suppressed.push({ id: candidate.id, layer: candidate.layer, reason: 'intent_suppresses_memory' });
+                continue;
+            }
+            if (!allowedLayers.includes(candidate.layer)) {
+                suppressed.push({ id: candidate.id, layer: candidate.layer, reason: 'layer_not_activated' });
+                continue;
+            }
+            if (seen.has(candidate.id)) {
+                suppressed.push({ id: candidate.id, layer: candidate.layer, reason: 'duplicate' });
+                continue;
+            }
+            seen.add(candidate.id);
+            eligible.push({ candidate, tokens: this.estimateTokens(candidate) });
+        }
+        eligible.sort((a, b) => {
+            const layerDelta = allowedLayers.indexOf(a.candidate.layer) - allowedLayers.indexOf(b.candidate.layer);
+            return layerDelta || (b.candidate.confidence ?? 0.5) - (a.candidate.confidence ?? 0.5) || a.candidate.id.localeCompare(b.candidate.id);
+        });
+        for (const item of eligible) {
+            if (usedTokens + item.tokens > budgetTokens) {
+                suppressed.push({ id: item.candidate.id, layer: item.candidate.layer, reason: 'budget_exceeded' });
+                continue;
+            }
+            selected.push(item.candidate);
+            usedTokens += item.tokens;
+            selectedReceipt.push({
+                id: item.candidate.id,
+                layer: item.candidate.layer,
+                tokens: item.tokens,
+                reason: input.strategy ? `activated_for:${intent}:${input.strategy.templateId}` : `activated_for:${intent}`,
+            });
+        }
+        const receipt = {
+            receiptId: `context-${randomUUID()}`,
+            query: input.query,
+            intent,
+            projectId: input.projectId,
+            budgetTokens,
+            usedTokens,
+            strategyId: input.strategy?.capsuleId,
+            strategyTemplate: input.strategy?.templateId,
+            selected: selectedReceipt,
+            suppressed,
+            createdAt: Date.now(),
+        };
+        this.persistReceipt(receipt);
+        return { intent, budgetTokens, usedTokens, selected, receipt, strategy: input.strategy };
+    }
+    getReceipt(receiptId) {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`SELECT receipt_json FROM context_activation_receipts WHERE receipt_id = ?`).get(receiptId);
+        return row ? JSON.parse(row.receipt_json) : null;
+    }
+    hardSuppressionReason(candidate, input, intent) {
+        if (input.projectId && candidate.projectId && candidate.projectId !== input.projectId)
+            return 'project_boundary';
+        if (candidate.superseded)
+            return 'superseded';
+        if (input.currentSessionId && candidate.sessionId === input.currentSessionId
+            && candidate.layer !== 'session_state' && candidate.layer !== 'turn_bridge')
+            return 'current_session_echo';
+        if (candidate.ownership === 'user' && !candidate.sourceRoles?.includes('user'))
+            return 'user_belief_without_user_evidence';
+        if (candidate.sensitive && !input.allowSensitive && intent !== 'exact_quote')
+            return 'sensitive_without_need';
+        return undefined;
+    }
+    estimateTokens(candidate) {
+        if (Number.isFinite(candidate.estimatedTokens) && Number(candidate.estimatedTokens) > 0) {
+            return Math.ceil(Number(candidate.estimatedTokens));
+        }
+        return Math.max(1, Math.ceil(candidate.content.length / 4));
+    }
+    persistReceipt(receipt) {
+        if (!this.db)
+            return;
+        this.db.prepare(`
+      INSERT INTO context_activation_receipts (
+        receipt_id, project_id, intent, budget_tokens, used_tokens, receipt_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(receipt.receiptId, receipt.projectId ?? null, receipt.intent, receipt.budgetTokens, receipt.usedTokens, JSON.stringify(receipt), receipt.createdAt);
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS context_activation_receipts (
+        receipt_id TEXT PRIMARY KEY, project_id TEXT, intent TEXT NOT NULL,
+        budget_tokens INTEGER NOT NULL, used_tokens INTEGER NOT NULL,
+        receipt_json TEXT NOT NULL, created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_context_activation_project_time
+        ON context_activation_receipts(project_id, created_at DESC);
+    `);
+    }
+}

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ContextCortex.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/context/index.js

@@ -0,0 +1 @@
+export * from './ContextCortex.js';

package/dist/core/ImportanceLevels.d.ts

@@ -0,0 +1,4 @@
+import type { MemoryImportanceLevel } from '../types/index.js';
+export declare const IMPORTANCE_STABILITY_MAP: Record<MemoryImportanceLevel, number>;
+export type ImportanceLevel = keyof typeof IMPORTANCE_STABILITY_MAP;
+//# sourceMappingURL=ImportanceLevels.d.ts.map

package/dist/core/ImportanceLevels.js

@@ -0,0 +1,6 @@
+export const IMPORTANCE_STABILITY_MAP = {
+    low: 0.35,
+    normal: 1.0,
+    important: 90.0,
+    permanent: 9999.0
+};

package/dist/core/IntentParser.d.ts

@@ -0,0 +1,12 @@
+import type { QueryIR } from '../types/query-ir.js';
+export declare class IntentParser {
+    static parse(query: string): QueryIR;
+    private static extractEntities;
+    private static detectIntent;
+    private static extractTemporal;
+    private static extractSpatial;
+    private static extractConstraints;
+    private static extractSemantics;
+    private static detectPredicateHint;
+}
+//# sourceMappingURL=IntentParser.d.ts.map

package/dist/core/IntentParser.js

@@ -0,0 +1,211 @@
+// ============================================
+// IntentParser - 意图解析器（轻量级规则/正则）
+// ============================================
+const TEMPORAL_KEYWORDS = {
+    '今天': { relative: 'today' },
+    '昨天': { relative: 'yesterday' },
+    '本周': { relative: 'this_week' },
+    '上周': { relative: 'last_week' },
+    '这个月': { relative: 'this_month' },
+    '上个月': { relative: 'last_month' },
+    '今年': { relative: 'this_year' },
+    '去年': { relative: 'last_year' },
+    '近半年': { relative: 'past_six_months' },
+    '过去半年': { relative: 'past_six_months' },
+    '近一年': { relative: 'past_year' },
+    '过去一年': { relative: 'past_year' },
+    '半年前': { relative: 'around_half_year_ago' },
+    'today': { relative: 'today' },
+    'yesterday': { relative: 'yesterday' },
+    'this week': { relative: 'this_week' },
+    'last week': { relative: 'last_week' },
+    'this year': { relative: 'this_year' },
+    'last year': { relative: 'last_year' },
+    'past six months': { relative: 'past_six_months' },
+    'last 6 months': { relative: 'past_six_months' },
+    'past year': { relative: 'past_year' },
+    'half year ago': { relative: 'around_half_year_ago' }
+};
+const INTENT_KEYWORDS = {
+    '查找': 'recall', '找': 'recall', 'recall': 'recall', 'search': 'recall',
+    '追溯': 'trace', 'trace': 'trace', '溯源': 'trace',
+    '更新': 'update', 'update': 'update', '修改': 'update'
+};
+const ENTITY_STOPWORDS = new Set([
+    '的', '了', '是', '在', '和', '与', '或',
+    'the', 'a', 'an', 'is', 'are', 'show', 'for', 'my', 'what', 'which',
+    'preference', 'decision', 'constraint', 'workflow', 'history'
+]);
+export class IntentParser {
+    static parse(query) {
+        const lowerQuery = query.toLowerCase();
+        const entities = this.extractEntities(query);
+        const intentType = this.detectIntent(lowerQuery);
+        const temporal = this.extractTemporal(lowerQuery);
+        const spatial = this.extractSpatial(query);
+        const { mustMatch, shouldMatch } = this.extractConstraints(query, entities);
+        const semantics = this.extractSemantics(query, lowerQuery, entities, mustMatch, shouldMatch);
+        return {
+            rawQuery: query,
+            entities,
+            intentType,
+            temporal,
+            spatial,
+            mustMatch,
+            shouldMatch,
+            semantics
+        };
+    }
+    static extractEntities(query) {
+        const words = query.split(/[\s,，。！？、]+/);
+        return words
+            .map((word) => word.replace(/^[^\p{L}\p{N}._-]+|[^\p{L}\p{N}._-]+$/gu, ''))
+            .filter(w => w.length >= 2 && !ENTITY_STOPWORDS.has(w.toLowerCase()) && !/^\d+$/.test(w))
+            .slice(0, 10);
+    }
+    static detectIntent(query) {
+        for (const [kw, type] of Object.entries(INTENT_KEYWORDS)) {
+            if (query.includes(kw))
+                return type;
+        }
+        return 'recall';
+    }
+    static extractTemporal(query) {
+        for (const [kw, constraint] of Object.entries(TEMPORAL_KEYWORDS)) {
+            if (query.includes(kw.toLowerCase()))
+                return constraint;
+        }
+        // 尝试解析具体日期（YYYY-MM-DD）
+        const dateMatch = query.match(/(\d{4}-\d{2}-\d{2})/);
+        if (dateMatch) {
+            const ts = new Date(dateMatch[1]).getTime();
+            return { start: ts, end: ts + 86400000 };
+        }
+        return {};
+    }
+    static extractSpatial(query) {
+        const result = {};
+        // 提取项目ID（project:xxx）
+        const projectMatch = query.match(/project[:：]\s*([\w.-]+)/i);
+        if (projectMatch)
+            result.projectId = projectMatch[1];
+        // 提取文件类型（.ts, .js）
+        const extMatch = query.match(/\.(\w+)$/);
+        if (extMatch)
+            result.fileType = extMatch[1];
+        return result;
+    }
+    static extractConstraints(query, entities) {
+        // 引号内容为硬约束
+        const quoted = query.match(/["「『]([^"」』]+)["」』]/g) || [];
+        const mustMatch = quoted.map(q => q.replace(/["「」『』]/g, ''));
+        // 其他实体为软约束
+        const shouldMatch = entities.filter(e => !mustMatch.includes(e));
+        return { mustMatch, shouldMatch };
+    }
+    static extractSemantics(query, lowerQuery, entities, mustMatch, shouldMatch) {
+        const predicateHint = this.detectPredicateHint(lowerQuery);
+        const subjectHint = /(我|i|my|mine)/i.test(query) ? 'user' : undefined;
+        const valueHints = [];
+        if (/(喜欢|like|prefer)/i.test(query))
+            valueHints.push('like');
+        if (/(讨厌|dislike|不喜欢)/i.test(query))
+            valueHints.push('dislike');
+        if (/(必须|must use)/i.test(query))
+            valueHints.push('required');
+        if (/(不能|禁止|must not|do not use|don't use)/i.test(query))
+            valueHints.push('forbidden');
+        if (/(选择|决定|choose|decide)/i.test(query))
+            valueHints.push('selected');
+        if (/(retry|重试)/i.test(query))
+            valueHints.push('retry');
+        if (/(rollback|回滚)/i.test(query))
+            valueHints.push('rollback');
+        if (/(recover|recovery|恢复)/i.test(query))
+            valueHints.push('recover');
+        if (/(redeploy|重新部署)/i.test(query))
+            valueHints.push('redeploy');
+        if (/(backoff|退避)/i.test(query))
+            valueHints.push('backoff');
+        if (/(merge|合并)/i.test(query))
+            valueHints.push('merge');
+        if (/(branch|分支)/i.test(query))
+            valueHints.push('branch');
+        if (/(state|状态|transition|迁移)/i.test(query))
+            valueHints.push('state_transition');
+        if (/(policy|策略)/i.test(query))
+            valueHints.push('policy');
+        const conditionHints = [];
+        const conditionalMatches = query.match(/如果.+?(?=[，,]|$)|if\s+.+?(?=[,，]|$)/ig) || [];
+        for (const item of conditionalMatches)
+            conditionHints.push(item.trim());
+        const environmentHints = [];
+        const envMatches = query.match(/production|prod|staging|stage|dev|development|test|测试|生产|预发|开发/ig) || [];
+        for (const item of envMatches)
+            environmentHints.push(item.toLowerCase());
+        const stateHints = [];
+        const stateMatches = query.match(/pending|running|healthy|failed|success|approved|approval|等待|运行中|健康|失败|成功|已批准|审批/ig) || [];
+        for (const item of stateMatches)
+            stateHints.push(item.toLowerCase());
+        const policyHints = [];
+        const policyMatches = query.match(/policy|策略|circuit-breaker|canary|strict|lenient|fallback|quota|rate-limit/ig) || [];
+        for (const item of policyMatches)
+            policyHints.push(item.toLowerCase());
+        const guardHints = [];
+        const guardMatches = query.match(/guard|approval|approved|gate|准入|批准|审批/ig) || [];
+        for (const item of guardMatches)
+            guardHints.push(item.toLowerCase());
+        const executorHints = [];
+        const executorMatches = query.match(/executor|runner|worker-runner|agent-runner|执行器|执行/ig) || [];
+        for (const item of executorMatches)
+            executorHints.push(item.toLowerCase());
+        const validationHints = [];
+        const validationMatches = query.match(/validate|validation|校验|check|health|quota|smoke|metrics/ig) || [];
+        for (const item of validationMatches)
+            validationHints.push(item.toLowerCase());
+        const mergeHints = [];
+        const mergeMatches = query.match(/merge|合并|release|propagate|传播/ig) || [];
+        for (const item of mergeMatches)
+            mergeHints.push(item.toLowerCase());
+        const entityHints = Array.from(new Set([...mustMatch, ...shouldMatch, ...entities]))
+            .map((item) => item.replace(/^[^\p{L}\p{N}._-]+|[^\p{L}\p{N}._-]+$/gu, ''))
+            .map((item) => item.toLowerCase())
+            .filter((item) => item.length >= 2)
+            .filter((item) => !ENTITY_STOPWORDS.has(item))
+            .filter((item) => !/(喜欢|讨厌|必须|不能|workflow|graph|history|历史|版本|偏好|决定|约束)/i.test(item));
+        return {
+            subjectHint,
+            predicateHint,
+            entityHints,
+            valueHints: Array.from(new Set(valueHints)),
+            conditionHints,
+            environmentHints: Array.from(new Set(environmentHints)),
+            stateHints: Array.from(new Set(stateHints)),
+            policyHints: Array.from(new Set(policyHints)),
+            guardHints: Array.from(new Set(guardHints)),
+            executorHints: Array.from(new Set(executorHints)),
+            validationHints: Array.from(new Set(validationHints)),
+            mergeHints: Array.from(new Set(mergeHints)),
+            asksForHistory: /(历史|history|版本|变化|contradiction|冲突)/i.test(query)
+        };
+    }
+    static detectPredicateHint(query) {
+        if (/(喜欢|讨厌|偏好|prefer|preference|dislike|like)/i.test(query))
+            return 'preference';
+        if (/(决定|选择|choose|decision|decide)/i.test(query))
+            return 'decision';
+        if (/(约束|限制|必须|不能|constraint|rule)/i.test(query))
+            return 'constraint';
+        if (/(计划|plan|rollback|recover|recovery|redeploy|retry|execute|executor|执行|validate|校验|merge|传播)/i.test(query))
+            return 'plan';
+        if (/(workflow|流程|工作流)/i.test(query))
+            return 'workflow';
+        if (/(graph|架构|依赖链|拓扑)/i.test(query))
+            return 'graph';
+        if (/(先|再|then|first|步骤|sequence)/i.test(query))
+            return 'sequence';
+        if (/(事实|配置|地址|api|endpoint|database|port|which|what is)/i.test(query))
+            return 'fact';
+        return undefined;
+    }
+}

package/dist/core/MemoryGraph.d.ts

@@ -0,0 +1,100 @@
+import type { MemoryAnchor, MemoryImportanceLevel, Neuron, NeuronMetadata, NeuronType, Synapse, TopicNode } from '../types/index.js';
+export interface VectorPageRow {
+    id: string;
+    vector: number[];
+}
+export interface TopicReclassifiedObservation {
+    type: 'TopicReclassified';
+    neuronId: string;
+    projectId?: string;
+    from: string | undefined;
+    to: string | undefined;
+    content: string;
+    timestamp: number;
+}
+export declare class MemoryGraph {
+    private db;
+    private timeIndex;
+    private projectIndex;
+    private anchorIndex;
+    private topicReclassifiedListeners;
+    constructor(dbPath?: string);
+    private initializeSchema;
+    private ensureCompatibilityColumns;
+    addNeuron(neuron: Neuron): void;
+    addNeuronInTransaction(neuron: Neuron): void;
+    private insertNeuron;
+    private insertIntoFTS;
+    rebuildIndexes(): void;
+    private updateMemoryIndexes;
+    addSynapse(sourceId: string, synapse: Synapse): void;
+    getNeuron(id: string): Neuron | null;
+    getNeuronIdsByProject(projectId: string): string[];
+    getSynapses(sourceId: string): Synapse[];
+    getAllNeurons(): Neuron[];
+    findNeuronsByType(type: NeuronType, options?: {
+        projectId?: string;
+        topicPath?: string;
+        limit?: number;
+    }): Neuron[];
+    listNeuronsByTimeRange(startTime: number, endTime: number, projectId?: string): Neuron[];
+    private mapNeuron;
+    private encodeAaakSummary;
+    private decodeAaakSummary;
+    private decodeProceduralLink;
+    private decodeVectorBlob;
+    createAnchor(neuronIds: string[], projectId?: string): MemoryAnchor;
+    private computeAnchorSummary;
+    getLatestAnchor(projectId?: string): MemoryAnchor | null;
+    getLatestNeuronSelfHash(projectId?: string): string | null;
+    fullTextSearch(query: string, projectId?: string, limit?: number): string[];
+    private toFTSQuery;
+    private extractFallbackSearchTokens;
+    private fallbackTextSearch;
+    transaction(fn: () => void): void;
+    close(): void;
+    getStats(): {
+        neuronCount: number;
+        synapseCount: number;
+        anchorCount: number;
+    };
+    findSimilarNeurons(vector: number[], topK: number): Array<{
+        id: string;
+        score: number;
+    }>;
+    private cosineSimilarity;
+    updateNeuronStatus(neuronId: string, status: 'active' | 'cold' | 'archived'): void;
+    updateNeuronMetadata(neuronId: string, metadata: Partial<NeuronMetadata>): void;
+    onTopicReclassified(listener: (observation: TopicReclassifiedObservation) => void): () => void;
+    getTopicPaths(projectId?: string): string[];
+    getNeuronIdsByTopicPrefix(prefix: string, projectId?: string): string[];
+    buildTopicTree(projectId?: string): TopicNode[];
+    updateNeuronContent(neuronId: string, content: string): void;
+    updateNeuronImportance(neuronId: string, importanceLevel: MemoryImportanceLevel, isPinned?: boolean): void;
+    listPinnedNeurons(options?: number | {
+        limit?: number;
+        projectId?: string;
+    }): Neuron[];
+    getRecentNeurons(options?: {
+        sinceMs?: number;
+        limit?: number;
+        projectId?: string;
+    }): Neuron[];
+    hasSynapse(sourceId: string, targetId: string): boolean;
+    getNeuronEnergy(neuronId: string): number;
+    getOrphanNeuronIds(limit: number): string[];
+    getNeuronIdsForReinforcement(limit: number): string[];
+    getNeuronIdsForTransition(limit: number): string[];
+    getArchivedFileNeurons(): Neuron[];
+    iterateNeuronVectors(pageSize: number, options?: {
+        includeStatuses?: Array<'active' | 'cold' | 'suspect' | 'archived'>;
+        projectId?: string;
+        onlyNotDeleted?: boolean;
+    }): IterableIterator<VectorPageRow[]>;
+    forEachNeuronVectorPage(pageSize: number, onPage: (rows: VectorPageRow[]) => Promise<void> | void, options?: {
+        includeStatuses?: Array<'active' | 'cold' | 'suspect' | 'archived'>;
+        projectId?: string;
+        onlyNotDeleted?: boolean;
+    }): Promise<void>;
+}
+//# sourceMappingURL=MemoryGraph.d.ts.map