cogmem 3.6.5 → 3.7.1

package/dist/atlas/EpisodeTitleGenerator.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryEvent } from '../types/index.js';
+export interface EpisodeTitleInput {
+    episodeId: string;
+    summary?: string | null;
+    topicPath?: string | null;
+    episodeType?: string | null;
+    startedAt?: number | null;
+    events: MemoryEvent[];
+}
+export interface EpisodeTitleResult {
+    displayTitle: string;
+    oneLineSummary: string;
+    topicHints: string[];
+    issueHints: string[];
+    eventKind: string;
+    userIntent?: string;
+    localDate?: string;
+    confidence: number;
+    reviewNeeded: boolean;
+    sourceEventIds: string[];
+    generatorTrace: {
+        usedUserText: boolean;
+        usedAssistantText: boolean;
+        fallback: boolean;
+        matchedRules: string[];
+    };
+}
+export declare class EpisodeTitleGenerator {
+    generate(input: EpisodeTitleInput): EpisodeTitleResult;
+}
+//# sourceMappingURL=EpisodeTitleGenerator.d.ts.map

package/dist/atlas/EpisodeTitleGenerator.js

@@ -0,0 +1,191 @@
+import { eventTextForMemory } from '../episode/CogmemBlockStripper.js';
+import { extractEntityCues, inferOperationalActionCue } from '../utils/EntityCueExtractor.js';
+const TITLE_RULES = [
+    {
+        id: 'memory_context_blackbox',
+        test: (text) => /(cogmem memory context|memory context|sourcecontext|source context|原文下钻|上下文.*黑盒|记忆上下文|摘要.*原话|记忆黑盒)/i.test(text) &&
+            !/(database locked|zombie|卡死|atlas|节点|事件名称|manual recall.*before_prompt_build|手动.*recall.*自动注入)/i.test(text),
+        displayTitle: 'CogMem Memory Context 黑盒与原文下钻',
+        oneLineSummary: '用户指出注入的 CogMem Memory Context 像黑盒，需要能从摘要下钻到原始对话。',
+        topicHints: ['memory-blackbox', 'source-drilldown', 'context-injection'],
+        issueHints: ['memory-context-blackbox'],
+        eventKind: 'diagnostic',
+        userIntent: 'inspect_original_context',
+        confidence: 0.92,
+    },
+    {
+        id: 'graph_runtime_blackbox',
+        test: (text) => /(memory graph|graph.*卡死|卡死|database locked|sqlite.*lock|zombie|僵尸进程|锁冲突)/i.test(text),
+        displayTitle: 'memory graph 卡死与数据库锁',
+        oneLineSummary: '用户遇到 memory graph 卡死、SQLite 锁冲突或残留进程，导致图谱与召回命令不稳定。',
+        topicHints: ['memory-blackbox', 'graph-runtime', 'sqlite-locks'],
+        issueHints: ['graph-runtime-blackbox'],
+        eventKind: 'bug',
+        userIntent: 'debug_graph_runtime',
+        confidence: 0.9,
+    },
+    {
+        id: 'atlas_readability_blackbox',
+        test: (text) => /(atlas|图谱|节点|事件名称|父主题|多维|facet|canonical|可读性|label|标题)/i.test(text),
+        displayTitle: 'Atlas 节点命名与多维导航',
+        oneLineSummary: '用户要求 Atlas 节点拥有清晰事件标题，并通过时间、主题、issue、实体等 facet 导航到同一份 canonical episode。',
+        topicHints: ['memory-blackbox', 'atlas-readability', 'facet-navigation'],
+        issueHints: ['atlas-readability'],
+        eventKind: 'plan',
+        userIntent: 'improve_atlas_navigation',
+        confidence: 0.88,
+    },
+    {
+        id: 'auto_injection_mismatch',
+        test: (text) => /((manual recall|手动.*recall|CLI).*(自动注入|before_prompt_build|OpenClaw)|(自动注入|before_prompt_build|OpenClaw).*(manual recall|手动.*recall|CLI)|注入.*不一致|selected.*different|选择.*不同)/i.test(text),
+        displayTitle: '自动注入与手动 recall 不一致',
+        oneLineSummary: '用户发现 OpenClaw 自动注入与手动 recall 的记忆选择不一致，需要暴露选择依据和匹配 facet。',
+        topicHints: ['context-injection', 'memory-blackbox', 'openclaw'],
+        issueHints: ['auto-injection-mismatch'],
+        eventKind: 'diagnostic',
+        userIntent: 'align_auto_injection',
+        confidence: 0.89,
+    },
+];
+export class EpisodeTitleGenerator {
+    generate(input) {
+        const userEvents = input.events.filter((event) => event.role === 'user');
+        const assistantEvents = input.events.filter((event) => event.role === 'assistant' || event.role === 'agent');
+        const userText = normalizeText(userEvents.map(eventTextForMemory).join('\n'));
+        const assistantText = normalizeText(assistantEvents.map(eventTextForMemory).join('\n'));
+        const summaryText = normalizeText([input.summary, input.topicPath, input.episodeType].filter(Boolean).join('\n'));
+        const preferredText = [userText, summaryText, assistantText].filter(Boolean).join('\n');
+        const operationTitle = inferOperationTitle(preferredText);
+        const matchedRule = TITLE_RULES.find((rule) => rule.test(preferredText));
+        const localDate = inferLocalDate(input.events, input.startedAt);
+        const sourceEventIds = sourceIdsFor(userEvents.length > 0 ? userEvents : input.events);
+        if (matchedRule) {
+            const matchedSourceEventIds = sourceIdsForMatching(userEvents.length > 0 ? userEvents : input.events, matchedRule.test) || sourceEventIds;
+            return {
+                displayTitle: boundTitle(matchedRule.displayTitle),
+                oneLineSummary: matchedRule.oneLineSummary,
+                topicHints: matchedRule.topicHints,
+                issueHints: matchedRule.issueHints,
+                eventKind: matchedRule.eventKind,
+                userIntent: matchedRule.userIntent,
+                localDate,
+                confidence: matchedRule.confidence,
+                reviewNeeded: matchedRule.confidence < 0.65,
+                sourceEventIds: matchedSourceEventIds,
+                generatorTrace: {
+                    usedUserText: userText.length > 0,
+                    usedAssistantText: userText.length === 0 && assistantText.length > 0,
+                    fallback: false,
+                    matchedRules: [matchedRule.id],
+                },
+            };
+        }
+        if (operationTitle) {
+            const matchedSourceEventIds = sourceIdsForMatching(userEvents.length > 0 ? userEvents : input.events, (text) => Boolean(inferOperationTitle(text))) || sourceEventIds;
+            return {
+                displayTitle: boundTitle(operationTitle.displayTitle),
+                oneLineSummary: operationTitle.oneLineSummary,
+                topicHints: operationTitle.topicHints,
+                issueHints: [],
+                eventKind: 'operation',
+                userIntent: 'action_history',
+                localDate,
+                confidence: 0.82,
+                reviewNeeded: false,
+                sourceEventIds: matchedSourceEventIds,
+                generatorTrace: {
+                    usedUserText: userText.length > 0,
+                    usedAssistantText: userText.length === 0 && assistantText.length > 0,
+                    fallback: false,
+                    matchedRules: ['generic_entity_operation'],
+                },
+            };
+        }
+        const fallbackTitle = fallbackDisplayTitle({ userText, summaryText, topicPath: input.topicPath, episodeType: input.episodeType });
+        return {
+            displayTitle: fallbackTitle,
+            oneLineSummary: fallbackSummary({ userText, summaryText, topicPath: input.topicPath }),
+            topicHints: inferTopicHints(preferredText),
+            issueHints: [],
+            eventKind: normalizeKind(input.episodeType) ?? 'explanation',
+            localDate,
+            confidence: 0.55,
+            reviewNeeded: true,
+            sourceEventIds,
+            generatorTrace: {
+                usedUserText: userText.length > 0,
+                usedAssistantText: userText.length === 0 && assistantText.length > 0,
+                fallback: true,
+                matchedRules: [],
+            },
+        };
+    }
+}
+function normalizeText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function inferOperationTitle(text) {
+    const action = inferOperationalActionCue(text);
+    const entity = extractEntityCues(text, 1)[0];
+    if (!action || !entity)
+        return undefined;
+    return {
+        displayTitle: `${entity.label} ${action.label}`,
+        oneLineSummary: `用户要求对 ${entity.label} 执行${action.verb}相关操作。`,
+        topicHints: [entity.id],
+    };
+}
+function sourceIdsFor(events) {
+    return events.map((event) => event.eventId).filter(Boolean).slice(0, 20);
+}
+function sourceIdsForMatching(events, test) {
+    const matched = events.filter((event) => test(eventTextForMemory(event)));
+    return matched.length ? sourceIdsFor(matched) : undefined;
+}
+function inferLocalDate(events, startedAt) {
+    for (const event of events) {
+        const candidate = event.localDate;
+        if (candidate && /^\d{4}-\d{2}-\d{2}$/.test(candidate))
+            return candidate;
+    }
+    const timestamp = events.find((event) => Number.isFinite(event.occurredAt))?.occurredAt ?? startedAt;
+    if (!timestamp || !Number.isFinite(timestamp))
+        return undefined;
+    return new Date(timestamp).toISOString().slice(0, 10);
+}
+function boundTitle(title) {
+    const clean = normalizeText(title).replace(/[0-9a-f]{8}-[0-9a-f-]{12,}/gi, '').trim();
+    if (/[^\x00-\x7F]/.test(clean))
+        return clean.length > 32 ? `${clean.slice(0, 31)}…` : clean;
+    const words = clean.split(/\s+/);
+    return words.length > 12 ? words.slice(0, 12).join(' ') : clean;
+}
+function fallbackDisplayTitle(input) {
+    const source = input.userText || input.summaryText || input.topicPath || input.episodeType || 'Untitled episode';
+    const firstSentence = source.split(/[。.!?\n]/).find(Boolean) ?? source;
+    const title = boundTitle(firstSentence);
+    if (!title || /^episode[:\s-]*[0-9a-f-]+$/i.test(title))
+        return '未命名记忆事件';
+    return title;
+}
+function fallbackSummary(input) {
+    const source = input.summaryText || input.userText || input.topicPath || '该 episode 缺少可读摘要，需要人工复核。';
+    const sentence = source.split(/[。.!?\n]/).find(Boolean) ?? source;
+    return normalizeText(sentence).slice(0, 140);
+}
+function inferTopicHints(text) {
+    const hints = new Set();
+    if (/cogmem|记忆|memory/i.test(text))
+        hints.add('memory');
+    if (/openclaw/i.test(text))
+        hints.add('openclaw');
+    for (const entity of extractEntityCues(text, 4))
+        hints.add(entity.id);
+    return Array.from(hints);
+}
+function normalizeKind(kind) {
+    if (!kind)
+        return undefined;
+    const normalized = kind.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    return normalized || undefined;
+}

package/dist/atlas/FacetQueryPlanner.d.ts

@@ -0,0 +1,33 @@
+export type FacetType = 'time' | 'topic' | 'issue' | 'entity' | 'session' | 'thread' | 'memoryKind' | 'actionKind';
+export type FacetOperator = 'intersection' | 'union';
+export interface PlannedFacet {
+    type: FacetType;
+    value: string;
+    label: string;
+    nodeId?: string;
+    relation?: string;
+    granularity?: 'year' | 'month' | 'day';
+    from?: number;
+    to?: number;
+}
+export interface FacetQueryPlan {
+    intent: string;
+    operator: FacetOperator;
+    facets: PlannedFacet[];
+    temporalIntent?: 'timeline';
+    groupBy?: 'topic' | 'time' | 'issue';
+    exactness: 'strict' | 'relaxed';
+    requiresIntersection: boolean;
+    keywords: string[];
+    query: string;
+}
+export interface FacetQueryPlannerOptions {
+    projectId: string;
+    now?: number;
+    localDateNow?: string;
+    timeZone?: string;
+}
+export declare class FacetQueryPlanner {
+    plan(query: string, options: FacetQueryPlannerOptions): FacetQueryPlan;
+}
+//# sourceMappingURL=FacetQueryPlanner.d.ts.map

package/dist/atlas/FacetQueryPlanner.js

@@ -0,0 +1,229 @@
+import { extractEntityCues } from '../utils/EntityCueExtractor.js';
+import { ACTION_KIND_RULES } from '../utils/ActionKindRegistry.js';
+const ISSUE_RULES = [
+    {
+        value: 'memory-context-blackbox',
+        label: 'Memory Context 黑盒',
+        test: (text) => /(memory context|sourcecontext|source context|上下文.*黑盒|记忆上下文|原文下钻|摘要.*原话)/i.test(text),
+    },
+    {
+        value: 'graph-runtime-blackbox',
+        label: 'Graph Runtime 黑盒',
+        test: (text) => /(memory graph|graph.*卡死|database locked|sqlite.*lock|zombie|僵尸进程|锁冲突|卡死)/i.test(text),
+    },
+    {
+        value: 'atlas-readability',
+        label: 'Atlas 可读性黑盒',
+        test: (text) => /(atlas|图谱|节点|事件名称|父主题|多维|facet|canonical|可读性|标题)/i.test(text),
+    },
+    {
+        value: 'auto-injection-mismatch',
+        label: '自动注入不一致',
+        test: (text) => /(自动注入|before_prompt_build|manual recall|手动.*recall|注入.*不一致|COGMEM_RECALL_CONTEXT)/i.test(text),
+    },
+];
+const TOPIC_RULES = [
+    {
+        value: 'memory-blackbox',
+        label: '记忆黑盒',
+        test: (text) => /(记忆黑盒|memory.*blackbox|memory context|sourcecontext|graph.*卡死|atlas|自动注入|上下文.*黑盒)/i.test(text),
+    },
+    {
+        value: 'source-drilldown',
+        label: '原文下钻',
+        test: (text) => /(sourcecontext|source context|原文下钻|摘要.*原文)/i.test(text),
+    },
+    {
+        value: 'context-injection',
+        label: '上下文注入',
+        test: (text) => /(自动注入|context injection|before_prompt_build|COGMEM_RECALL_CONTEXT|注入)/i.test(text),
+    },
+];
+export class FacetQueryPlanner {
+    plan(query, options) {
+        const normalized = query.trim();
+        const facets = [];
+        const actionHistory = isActionHistoryQuery(normalized);
+        const timeFacet = parseTimeFacet(normalized, options);
+        if (timeFacet)
+            facets.push(withNodeId(timeFacet, options.projectId));
+        const timeline = /(后来|继续|timeline|演化|发展|之后)/i.test(normalized);
+        const matchedIssueValues = new Set();
+        for (const rule of TOPIC_RULES) {
+            if (rule.test(normalized)) {
+                facets.push(withNodeId({ type: 'topic', value: `PROJECT/${options.projectId}/${rule.value}`, label: rule.label, relation: 'ABOUT_TOPIC' }, options.projectId));
+            }
+        }
+        for (const rule of ISSUE_RULES) {
+            if (rule.test(normalized)) {
+                facets.push(withNodeId({ type: 'issue', value: rule.value, label: rule.label, relation: 'PART_OF_ISSUE' }, options.projectId));
+                matchedIssueValues.add(rule.value);
+            }
+        }
+        if (!timeline && isBroadMemoryBlackbox(normalized) && matchedIssueValues.size === 0) {
+            facets.push(withNodeId({ type: 'issue', value: 'memory-context-blackbox', label: 'Memory Context 黑盒', relation: 'PART_OF_ISSUE' }, options.projectId));
+        }
+        for (const entity of extractEntityCues(normalized)) {
+            if (!actionHistory && isConceptFacetEntity(entity, facets))
+                continue;
+            facets.push({ type: 'entity', value: `facet:${entity.id}`, label: entity.label, nodeId: `entity:${options.projectId}:facet:${entity.id}`, relation: 'INVOLVES_ENTITY' });
+            if (actionHistory) {
+                facets.push(withNodeId({ type: 'topic', value: `PROJECT/${options.projectId}/${entity.id}`, label: entity.label, relation: 'ABOUT_TOPIC' }, options.projectId));
+            }
+        }
+        for (const facet of parseKindFacets(normalized, options.projectId))
+            facets.push(facet);
+        if (actionHistory && (!facets.some((facet) => facet.type === 'actionKind') || !hasSpecificActionCue(normalized))) {
+            for (const value of ['started', 'installed', 'configured', 'restarted', 'stopped', 'operated', 'implemented', 'debugged']) {
+                facets.push(withNodeId({ type: 'actionKind', value, label: value, relation: 'HAS_ACTION_KIND' }, options.projectId));
+            }
+        }
+        return {
+            intent: actionHistory ? 'action_history' : /聊过|记得|还记得|讨论|原话|那次/i.test(normalized) ? 'historical_discussion' : 'graph_search',
+            operator: 'intersection',
+            facets: dedupeFacets(facets),
+            temporalIntent: timeline ? 'timeline' : undefined,
+            groupBy: timeline ? 'time' : timeFacet && facets.length === 1 ? 'topic' : facets.some((facet) => facet.type === 'issue') ? 'issue' : undefined,
+            exactness: 'strict',
+            requiresIntersection: facets.length > 1,
+            keywords: extractKeywords(normalized),
+            query: normalized,
+        };
+    }
+}
+function isActionHistoryQuery(query) {
+    return /(让你.{0,20}(对|给|把)?.{0,20}(做过|做了|启动|安装|配置|修改|重启|停止|操作|处理|执行)|对.{0,30}(做过什么|做了什么|哪些操作)|what did (i ask you to do|you do) to|operations? on)/i.test(query);
+}
+function hasSpecificActionCue(query) {
+    return /(启动|start|started|launch|launched|boot|安装|install|installed|setup|配置|config|configured|设置|修改配置|重启|restart|停止|stop|修复|实现|implemented|review|审查|debug|排查|卡死|locked|zombie)/i.test(query);
+}
+function isBroadMemoryBlackbox(query) {
+    return /(记忆黑盒|memory.*blackbox)/i.test(query) &&
+        !/(memory graph|graph|database locked|sqlite|zombie|僵尸|卡死|atlas|图谱|节点|事件名称|自动注入|before_prompt_build|manual recall|手动.*recall)/i.test(query);
+}
+function isConceptFacetEntity(entity, facets) {
+    const label = entity.label.toLocaleLowerCase();
+    return facets.some((facet) => {
+        if (facet.type !== 'topic' && facet.type !== 'issue')
+            return false;
+        const facetLabel = facet.label.toLocaleLowerCase();
+        const facetSlug = facet.value.split('/').pop()?.toLocaleLowerCase();
+        return label === facetLabel || label.includes(facetLabel) || Boolean(facetSlug && entity.id === facetSlug);
+    });
+}
+function parseKindFacets(query, projectId) {
+    const facets = [];
+    const memoryKindRules = [
+        ['bug', /(bug|问题|卡死|failure|故障|错误|报错)/i],
+        ['decision', /(decision|决定|方案|结论)/i],
+        ['plan', /(计划|下一步|策略|plan)/i],
+    ];
+    for (const [value, test] of memoryKindRules) {
+        if (test.test(query))
+            facets.push(withNodeId({ type: 'memoryKind', value, label: value, relation: 'HAS_MEMORY_KIND' }, projectId));
+    }
+    for (const rule of ACTION_KIND_RULES) {
+        if (rule.pattern.test(query))
+            facets.push(withNodeId({ type: 'actionKind', value: rule.kind, label: rule.kind, relation: 'HAS_ACTION_KIND' }, projectId));
+    }
+    return facets;
+}
+function parseTimeFacet(query, options) {
+    const currentYear = localYear(options);
+    const isoDay = query.match(/(20\d{2})[-年\/.](\d{1,2})[-月\/.](\d{1,2})日?/);
+    if (isoDay)
+        return dayFacet(Number(isoDay[1]), Number(isoDay[2]), Number(isoDay[3]));
+    const cnDay = query.match(/(?:(20\d{2})年)?(\d{1,2})月(\d{1,2})(?:号|日)?/);
+    if (cnDay)
+        return dayFacet(cnDay[1] ? Number(cnDay[1]) : currentYear, Number(cnDay[2]), Number(cnDay[3]));
+    const isoMonth = query.match(/(20\d{2})[-年\/.](\d{1,2})月?/);
+    if (isoMonth)
+        return monthFacet(Number(isoMonth[1]), Number(isoMonth[2]));
+    const year = query.match(/\b(20\d{2})\b|((20\d{2})年)/);
+    if (year)
+        return yearFacet(Number(year[1] ?? year[3]));
+    if (/去年/.test(query))
+        return yearFacet(currentYear - 1);
+    return undefined;
+}
+function localYear(options) {
+    const explicit = options.localDateNow?.match(/^(20\d{2})-\d{2}-\d{2}$/u)?.[1];
+    if (explicit)
+        return Number(explicit);
+    const now = options.now ?? Date.now();
+    try {
+        const parts = new Intl.DateTimeFormat('en-CA', {
+            timeZone: options.timeZone || 'Asia/Tokyo',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        }).formatToParts(new Date(now));
+        const year = parts.find((part) => part.type === 'year')?.value;
+        if (year)
+            return Number(year);
+    }
+    catch { /* fall back below */ }
+    return new Date(now).getUTCFullYear();
+}
+function dayFacet(year, month, day) {
+    const label = `${year}-${pad(month)}-${pad(day)}`;
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_ON',
+        granularity: 'day',
+        from: Date.UTC(year, month - 1, day),
+        to: Date.UTC(year, month - 1, day + 1),
+    };
+}
+function monthFacet(year, month) {
+    const label = `${year}-${pad(month)}`;
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_IN',
+        granularity: 'month',
+        from: Date.UTC(year, month - 1, 1),
+        to: Date.UTC(year, month, 1),
+    };
+}
+function yearFacet(year) {
+    const label = String(year);
+    return {
+        type: 'time',
+        value: label,
+        label,
+        relation: 'OCCURRED_IN',
+        granularity: 'year',
+        from: Date.UTC(year, 0, 1),
+        to: Date.UTC(year + 1, 0, 1),
+    };
+}
+function withNodeId(facet, projectId) {
+    return {
+        ...facet,
+        nodeId: `${facet.type}:${projectId}:${facet.value}`,
+    };
+}
+function dedupeFacets(facets) {
+    const seen = new Set();
+    return facets.filter((facet) => {
+        const key = `${facet.type}:${facet.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function extractKeywords(query) {
+    return query
+        .split(/[^\p{L}\p{N}_-]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2)
+        .slice(0, 8);
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}

package/dist/atlas/GraphCurator.d.ts

@@ -0,0 +1,30 @@
+import type Database from 'bun:sqlite';
+import type { EventStore } from '../store/EventStore.js';
+import { MemoryAtlasStore } from '../store/MemoryAtlasStore.js';
+export interface GraphCuratorResult {
+    episodeCount: number;
+    facetNodeCount: number;
+    facetEdgeCount: number;
+    reviewNeeded: number;
+}
+export declare class GraphCurator {
+    private readonly db;
+    private readonly eventStore;
+    private readonly atlasStore;
+    private readonly titleGenerator;
+    constructor(db: Database, eventStore: EventStore, atlasStore: MemoryAtlasStore);
+    rebuild(projectId: string, now?: number): GraphCuratorResult;
+    rebuildEpisodes(projectId: string, episodeIds: string[], now?: number): GraphCuratorResult;
+    private projectEpisode;
+    private episodeEventIds;
+    private facetTargetsFor;
+    private upsertFacetNode;
+    private upsertRawEventNode;
+    private projectEpisodeRelations;
+    private upsertEpisodeRelation;
+    private entityHintsFor;
+    private deleteFacetEdges;
+    private deleteFacetEdgesForEpisodes;
+    private upsertEdge;
+}
+//# sourceMappingURL=GraphCurator.d.ts.map