cogmem 3.6.2

package/dist/adapters/openclaw/OpenClawWorkspaceProfile.js

@@ -0,0 +1,199 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { computeStableHash } from '../types.js';
+const REQUIRED_MEMORY_FILES = [
+    'MEMORY.md',
+    'memory',
+    'USER.md',
+    'SOUL.md',
+];
+const SESSION_DIR_CANDIDATES = [
+    'sessions',
+    'session-logs',
+    'session_logs',
+    'conversations',
+    join('exports', 'sessions'),
+    join('exports', 'conversations'),
+];
+const OPENCLAW_DAILY_MEMORY_FILE = /^\d{4}-\d{2}-\d{2}(?:-[A-Za-z0-9][A-Za-z0-9._-]*)?\.md$/i;
+export class OpenClawWorkspaceProfile {
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = resolve(workspaceRoot);
+    }
+    static discoverWorkspaceRoot(startPath) {
+        let current = resolve(startPath);
+        try {
+            if (!statSync(current).isDirectory())
+                current = dirname(current);
+        }
+        catch {
+            return null;
+        }
+        while (true) {
+            if (this.looksLikeWorkspaceRoot(current))
+                return current;
+            const parent = dirname(current);
+            if (parent === current)
+                return null;
+            current = parent;
+        }
+    }
+    static looksLikeWorkspaceRoot(candidate) {
+        return REQUIRED_MEMORY_FILES.some((entry) => existsSync(join(candidate, entry)));
+    }
+    classifyPath(filePath) {
+        const absolutePath = resolve(filePath);
+        const rel = relative(this.workspaceRoot, absolutePath);
+        const normalized = rel.replace(/\\/g, '/');
+        const name = basename(absolutePath);
+        if (name === 'USER.md') {
+            return this.result(absolutePath, normalized, 'identity_profile_source', 'openclaw_user_profile', 'Static user seed/profile source.');
+        }
+        if (name === 'SOUL.md' || name === 'IDENTITY.md' || name === 'PERSONA.md') {
+            return this.result(absolutePath, normalized, 'identity_profile_source', 'openclaw_persona', 'Agent persona/identity source, not episodic memory.');
+        }
+        if (name === 'MEMORY.md') {
+            return this.result(absolutePath, normalized, 'memory_source', 'openclaw_memory_index', 'Imported summary/index memory source.');
+        }
+        if (normalized.startsWith('memory/') && OPENCLAW_DAILY_MEMORY_FILE.test(name)) {
+            return this.result(absolutePath, normalized, 'memory_source', 'openclaw_daily_memory', 'Daily episodic memory source.');
+        }
+        if (this.isSessionPath(normalized)) {
+            return this.result(absolutePath, normalized, 'memory_source', 'openclaw_session', 'Session log / exported conversation source.');
+        }
+        if (name === 'AGENTS.md' || name === 'TOOLS.md' || name === 'HEARTBEAT.md' || name === 'BOOTSTRAP.md') {
+            return this.result(absolutePath, normalized, 'operational_ignore', undefined, 'Operational/bootstrap source; do not import into long-term brain by default.');
+        }
+        if (/(^|\/)(dialogues|threads|chatlogs|catchups?)\//i.test(normalized)) {
+            return this.result(absolutePath, normalized, 'unknown', undefined, 'Session-like markdown outside the default reference layout. Pass it explicitly as a session path.');
+        }
+        if (/(^|\/)(notes|project-memory|project_memory|daily-notes|memories)\//i.test(normalized)) {
+            return this.result(absolutePath, normalized, 'unknown', undefined, 'Memory-like markdown outside the default reference layout. Pass it explicitly as project memory.');
+        }
+        return this.result(absolutePath, normalized, 'unknown', undefined, 'Not part of the default OpenClaw reference workspace contract.');
+    }
+    listReferenceWorkspaceContract() {
+        return [
+            'SOUL.md',
+            'USER.md',
+            'PERSONA.md',
+            'IDENTITY.md',
+            'MEMORY.md',
+            join('memory', 'YYYY-MM-DD.md'),
+            join('memory', 'YYYY-MM-DD-<slug>.md'),
+            join('sessions', '<exported-conversation>.md'),
+            'AGENTS.md',
+            'TOOLS.md',
+            'HEARTBEAT.md',
+            'BOOTSTRAP.md',
+        ].map((entry) => this.classifyPath(join(this.workspaceRoot, entry)));
+    }
+    buildInstalledBatchSources(options = {}) {
+        return this.buildInstalledBatchSelection(options).sources;
+    }
+    buildInstalledBatchSelection(options = {}) {
+        const projectId = options.projectId || basename(this.workspaceRoot);
+        const discoveredPaths = new Set();
+        const diagnostics = new Map();
+        const date = options.date;
+        const maybeAdd = (path, explicit = false, mode) => {
+            const absolute = resolve(path);
+            const exists = existsSync(absolute) && statSync(absolute).isFile();
+            const classified = exists
+                ? (mode ? this.classifyExplicitPath(absolute, mode) : this.classifyPath(absolute))
+                : this.result(absolute, relative(this.workspaceRoot, absolute).replace(/\\/g, '/'), 'unknown', undefined, 'Explicit path does not exist or is not a file.');
+            const included = Boolean(exists && classified.adapterKind);
+            diagnostics.set(absolute, {
+                ...classified,
+                explicit,
+                exists,
+                included,
+            });
+            if (included)
+                discoveredPaths.add(absolute);
+        };
+        maybeAdd(join(this.workspaceRoot, 'USER.md'));
+        maybeAdd(join(this.workspaceRoot, 'SOUL.md'));
+        maybeAdd(join(this.workspaceRoot, 'PERSONA.md'));
+        maybeAdd(join(this.workspaceRoot, 'IDENTITY.md'));
+        maybeAdd(join(this.workspaceRoot, 'MEMORY.md'));
+        const memoryDir = join(this.workspaceRoot, 'memory');
+        if (date) {
+            maybeAdd(join(memoryDir, `${date}.md`));
+            if (existsSync(memoryDir)) {
+                for (const child of readdirSync(memoryDir)) {
+                    if (child.startsWith(`${date}-`) && OPENCLAW_DAILY_MEMORY_FILE.test(child))
+                        maybeAdd(join(memoryDir, child));
+                }
+            }
+        }
+        else if (existsSync(memoryDir)) {
+            for (const child of readdirSync(memoryDir)) {
+                if (OPENCLAW_DAILY_MEMORY_FILE.test(child))
+                    maybeAdd(join(memoryDir, child));
+            }
+        }
+        for (const sessionPath of options.sessionPaths || [])
+            maybeAdd(sessionPath, true, 'session');
+        for (const memoryPath of options.optionalMemoryPaths || [])
+            maybeAdd(memoryPath, true, 'project_memory');
+        if ((options.sessionPaths || []).length === 0) {
+            for (const sessionDir of SESSION_DIR_CANDIDATES) {
+                const dir = join(this.workspaceRoot, sessionDir);
+                if (!existsSync(dir))
+                    continue;
+                for (const child of readdirSync(dir)) {
+                    if (!/\.(md|markdown)$/i.test(child))
+                        continue;
+                    if (date && !child.includes(date))
+                        continue;
+                    maybeAdd(join(dir, child));
+                }
+            }
+        }
+        const sources = Array.from(discoveredPaths)
+            .map((path) => diagnostics.get(path) || this.classifyPath(path))
+            .filter((item) => item.adapterKind)
+            .map((item) => ({
+            sourceId: `openclaw-${item.adapterKind}-${computeStableHash([projectId, item.relativePath]).slice(0, 12)}`,
+            adapterKind: item.adapterKind,
+            sourcePath: item.path,
+            projectId,
+            tags: ['openclaw'],
+            metadata: {
+                openclawWorkspaceRoot: this.workspaceRoot,
+                openclawRelativePath: item.relativePath,
+                classification: item.classification,
+            },
+        }));
+        return {
+            sources,
+            diagnostics: Array.from(diagnostics.values()),
+        };
+    }
+    classifyExplicitPath(filePath, mode) {
+        const absolutePath = resolve(filePath);
+        const normalized = relative(this.workspaceRoot, absolutePath).replace(/\\/g, '/');
+        const name = basename(absolutePath);
+        if (mode === 'session') {
+            return this.result(absolutePath, normalized, 'memory_source', 'openclaw_session', 'Explicit session override accepted for non-standard layout.');
+        }
+        if (name === 'MEMORY.md') {
+            return this.result(absolutePath, normalized, 'memory_source', 'openclaw_memory_index', 'Explicit project-memory override accepted as imported memory index.');
+        }
+        return this.result(absolutePath, normalized, 'memory_source', 'openclaw_daily_memory', 'Explicit project-memory override accepted for non-standard layout.');
+    }
+    isSessionPath(relativePathValue) {
+        return SESSION_DIR_CANDIDATES.some((dir) => relativePathValue.startsWith(`${dir.replace(/\\/g, '/')}/`));
+    }
+    result(path, relativePathValue, classification, adapterKind, reason) {
+        return {
+            path,
+            relativePath: relativePathValue,
+            classification,
+            adapterKind,
+            reason,
+        };
+    }
+}

package/dist/adapters/soul/SoulMarkdownAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class SoulMarkdownAdapter implements SourceAdapter {
+    readonly kind: "soul_markdown";
+    private readonly adapterVersion;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+    private extractFrontmatter;
+    private parseSections;
+    private sectionToRecords;
+    private makeRecord;
+    private inferDocumentKind;
+    private inferSectionKind;
+    private matchLooseHeading;
+}
+//# sourceMappingURL=SoulMarkdownAdapter.d.ts.map

package/dist/adapters/soul/SoulMarkdownAdapter.js

@@ -0,0 +1,255 @@
+import { computeStableHash, inferSourceTitle, normalizeMarkdownText, parseLooseDateHeading, parseLooseTimestamp, parseMarkdownRoleLine, resolveTimestampWithContext } from '../types.js';
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+export class SoulMarkdownAdapter {
+    kind = 'soul_markdown';
+    adapterVersion = 'soul-markdown-v2';
+    adapt(source, snapshot, window) {
+        const normalized = normalizeMarkdownText(snapshot.content);
+        const { frontmatter, body } = this.extractFrontmatter(normalized);
+        const sections = this.parseSections(body);
+        const diagnostics = [];
+        const title = inferSourceTitle(source.sourcePath).toLowerCase();
+        const defaultKind = this.inferDocumentKind(frontmatter.type || title);
+        const defaultTimestamp = parseLooseTimestamp(frontmatter.created_at || frontmatter.date, snapshot.fileMtimeMs);
+        if (!frontmatter.type && !frontmatter.created_at && !frontmatter.date) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'soul_missing_frontmatter_fields',
+                message: 'Soul-like markdown is missing type/date frontmatter; the adapter fell back to filename and file mtime.',
+                filePath: source.sourcePath,
+                adapterKind: this.kind,
+                contractHint: 'Preferred fields are type plus created_at/date, but partial files are still ingested.',
+                fallbackHint: 'If time placement matters, add frontmatter or pass the file through the correct daily window.'
+            });
+        }
+        const allRecords = sections
+            .flatMap((section, index) => this.sectionToRecords(source, snapshot, section, {
+            defaultKind,
+            defaultTimestamp: defaultTimestamp + index,
+            projectId: frontmatter.project_id
+        }));
+        const records = allRecords
+            .filter((record) => !window || (record.timestamp >= window.start && record.timestamp < window.end));
+        return {
+            source: {
+                ...source,
+                projectId: source.projectId || frontmatter.project_id
+            },
+            snapshot: {
+                sourceId: snapshot.sourceId,
+                adapterKind: snapshot.adapterKind,
+                sourcePath: snapshot.sourcePath,
+                projectId: source.projectId || frontmatter.project_id,
+                fileHash: snapshot.fileHash,
+                fileMtimeMs: snapshot.fileMtimeMs,
+                fileSize: snapshot.fileSize,
+                readAt: snapshot.readAt
+            },
+            records,
+            diagnostics: allRecords.length > 0
+                ? diagnostics
+                : [
+                    ...diagnostics,
+                    {
+                        severity: 'error',
+                        code: 'soul_contract_mismatch',
+                        message: 'No ingestable soul/reflection/note content was found.',
+                        filePath: source.sourcePath,
+                        adapterKind: this.kind,
+                        contractHint: 'Expected headings, note paragraphs, or message-like lines inside a markdown note.',
+                        fallbackHint: 'Use repeated --soul for note-style files; if this is actually a transcript, pass it through --conversation instead.'
+                    }
+                ]
+        };
+    }
+    extractFrontmatter(content) {
+        const match = content.match(FRONTMATTER_RE);
+        if (!match)
+            return { frontmatter: {}, body: content };
+        const frontmatter = {};
+        for (const line of match[1].split('\n')) {
+            const separator = line.indexOf(':');
+            if (separator === -1)
+                continue;
+            const key = line.slice(0, separator).trim().toLowerCase();
+            const value = line.slice(separator + 1).trim();
+            if (key)
+                frontmatter[key] = value;
+        }
+        return {
+            frontmatter,
+            body: content.slice(match[0].length).trim()
+        };
+    }
+    parseSections(body) {
+        const lines = body.split('\n');
+        const sections = [];
+        let current = null;
+        let skipNextLine = false;
+        const flush = () => {
+            if (!current)
+                return;
+            const text = current.text.trim();
+            if (text)
+                sections.push({ ...current, text });
+            current = null;
+        };
+        lines.forEach((line, index) => {
+            if (skipNextLine) {
+                skipNextLine = false;
+                return;
+            }
+            const headingMatch = line.match(HEADING_RE) || this.matchLooseHeading(lines, index);
+            if (headingMatch) {
+                flush();
+                const heading = headingMatch[2]?.trim() || headingMatch[1]?.trim();
+                if (!heading)
+                    return;
+                if (/^[-=]{3,}$/.test(lines[index + 1]?.trim() || ''))
+                    skipNextLine = true;
+                current = {
+                    heading,
+                    text: '',
+                    lineNumber: index + 1
+                };
+                return;
+            }
+            if (!current) {
+                current = {
+                    heading: undefined,
+                    text: '',
+                    lineNumber: index + 1
+                };
+            }
+            current.text += `${current.text ? '\n' : ''}${line}`;
+        });
+        flush();
+        return sections;
+    }
+    sectionToRecords(source, snapshot, section, defaults) {
+        const records = [];
+        const lines = section.text.split('\n');
+        let currentMessage = null;
+        let currentDateHint = parseLooseDateHeading(section.heading || '') || undefined;
+        const pushMessage = () => {
+            if (!currentMessage)
+                return;
+            const text = currentMessage.text.trim();
+            if (!text)
+                return;
+            records.push(this.makeRecord(source, snapshot, {
+                kind: 'raw_utterance',
+                role: currentMessage.role,
+                text,
+                timestamp: currentMessage.timestamp,
+                lineNumber: currentMessage.lineNumber,
+                sectionHeading: section.heading
+            }));
+            currentMessage = null;
+        };
+        lines.forEach((line, index) => {
+            const headingDate = parseLooseDateHeading(line);
+            if (headingDate) {
+                currentDateHint = headingDate;
+                return;
+            }
+            const parsed = parseMarkdownRoleLine(line);
+            if (parsed) {
+                pushMessage();
+                currentMessage = {
+                    role: parsed.role,
+                    text: parsed.text,
+                    timestamp: resolveTimestampWithContext(parsed.timestamp, defaults.defaultTimestamp + index, currentDateHint),
+                    lineNumber: section.lineNumber + index
+                };
+                return;
+            }
+            if (currentMessage) {
+                currentMessage.text += `${currentMessage.text ? '\n' : ''}${line.trimEnd()}`;
+            }
+        });
+        pushMessage();
+        const residual = lines
+            .filter((line) => !parseMarkdownRoleLine(line) && !parseLooseDateHeading(line))
+            .join('\n')
+            .trim();
+        if (residual) {
+            records.push(this.makeRecord(source, snapshot, {
+                kind: this.inferSectionKind(section.heading, defaults.defaultKind),
+                text: residual,
+                timestamp: defaults.defaultTimestamp,
+                lineNumber: section.lineNumber,
+                sectionHeading: section.heading
+            }));
+        }
+        return records;
+    }
+    makeRecord(source, snapshot, input) {
+        const recordHash = computeStableHash([
+            source.sourceId,
+            input.kind,
+            input.role,
+            input.timestamp,
+            input.text
+        ]);
+        const title = inferSourceTitle(source.sourcePath);
+        const reliabilityClass = input.kind === 'raw_utterance'
+            ? 'raw_utterance'
+            : input.kind === 'reflection'
+                ? 'reflection'
+                : 'self_summary';
+        return {
+            recordId: `soul-${recordHash.slice(0, 16)}`,
+            kind: input.kind,
+            role: input.role,
+            text: input.text,
+            timestamp: input.timestamp,
+            tags: [title, 'soul', reliabilityClass],
+            confidenceHint: reliabilityClass === 'raw_utterance' ? 0.76 : reliabilityClass === 'reflection' ? 0.58 : 0.64,
+            sourceTypeHint: reliabilityClass === 'raw_utterance'
+                ? (input.role === 'agent' ? 'llm_inference' : 'user_input')
+                : 'llm_inference',
+            metadata: {
+                lineNumber: input.lineNumber,
+                sectionHeading: input.sectionHeading
+            },
+            provenance: {
+                sourceId: source.sourceId,
+                sourcePath: source.sourcePath,
+                sourceType: this.kind,
+                adapterVersion: this.adapterVersion,
+                fileHash: snapshot.fileHash,
+                fileMtimeMs: snapshot.fileMtimeMs,
+                recordHash,
+                reliabilityClass
+            }
+        };
+    }
+    inferDocumentKind(token) {
+        const lowered = (token || '').toLowerCase();
+        if (/reflect|reflection|retro|retrospective|catch-up|复盘|反思/.test(lowered))
+            return 'reflection';
+        if (/summary|memory-summary|wrap-up|digest|总结|摘要|概览/.test(lowered))
+            return 'self_summary';
+        return 'note';
+    }
+    inferSectionKind(heading, fallback) {
+        if (!heading)
+            return fallback;
+        return this.inferDocumentKind(heading);
+    }
+    matchLooseHeading(lines, index) {
+        const current = lines[index]?.trim();
+        const next = lines[index + 1]?.trim();
+        if (!current || !next)
+            return null;
+        const setext = current.match(/^([A-Za-z][A-Za-z /_-]{1,40}|[\u4e00-\u9fa5A-Za-z0-9 /_-]{1,20})$/);
+        if (setext && /^[-=]{3,}$/.test(next))
+            return [current, '#', current];
+        const labeled = current.match(/^(Summary|Reflection|Notes|Memory Notes|Catch[- ]?Up|Persona|Identity|User Profile|用户画像|人格|反思|总结|备注)\s*:?$/i);
+        if (labeled)
+            return [current, '#', labeled[1]];
+        return null;
+    }
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,97 @@
+import type { IngestInput, SourceType } from '../types/index.js';
+export type SourceAdapterKind = 'conversation_markdown' | 'soul_markdown' | 'hermes_state_db' | 'openclaw_daily_memory' | 'openclaw_session' | 'openclaw_memory_index' | 'openclaw_user_profile' | 'openclaw_persona';
+export type SourceRecordKind = 'conversation_message' | 'conversation_turn' | 'raw_utterance' | 'self_summary' | 'reflection' | 'note';
+export type SourceReliabilityClass = 'raw_utterance' | 'self_summary' | 'reflection' | 'imported_summary' | 'imported_profile';
+export type SourceActorRole = 'user' | 'agent' | 'system' | 'narrator';
+export interface SourceAdapterDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    filePath: string;
+    adapterKind: SourceAdapterKind;
+    lineNumber?: number;
+    contractHint?: string;
+    fallbackHint?: string;
+}
+export interface SourceDefinition {
+    sourceId: string;
+    adapterKind: SourceAdapterKind;
+    sourcePath: string;
+    projectId?: string;
+    enabled?: boolean;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface SourceFileSnapshot {
+    sourceId: string;
+    adapterKind: SourceAdapterKind;
+    sourcePath: string;
+    projectId?: string;
+    fileHash: string;
+    fileMtimeMs: number;
+    fileSize: number;
+    readAt: number;
+    content: string;
+}
+export interface SourceProvenance {
+    sourceId: string;
+    sourcePath: string;
+    sourceType: SourceAdapterKind;
+    adapterVersion: string;
+    fileHash: string;
+    fileMtimeMs: number;
+    recordHash: string;
+    reliabilityClass: SourceReliabilityClass;
+    lineStart?: number;
+    lineEnd?: number;
+    charStart?: number;
+    charEnd?: number;
+    sourceOffset?: number;
+    orderingConfidence?: 'high' | 'medium' | 'low';
+}
+export interface SourceAdapterRecord {
+    recordId: string;
+    turnId?: string;
+    kind: SourceRecordKind;
+    role?: SourceActorRole;
+    text: string;
+    timestamp: number;
+    tags: string[];
+    confidenceHint: number;
+    sourceTypeHint: SourceType;
+    metadata?: Record<string, unknown>;
+    provenance: SourceProvenance;
+}
+export interface AdaptedSource {
+    source: SourceDefinition;
+    snapshot: Omit<SourceFileSnapshot, 'content'>;
+    records: SourceAdapterRecord[];
+    diagnostics?: SourceAdapterDiagnostic[];
+}
+export interface AdapterWindow {
+    start: number;
+    end: number;
+}
+export interface SourceAdapter {
+    readonly kind: SourceAdapterKind;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+export interface BatchEpisodeEnvelope {
+    record: SourceAdapterRecord;
+    ingestInput: IngestInput;
+}
+export declare function computeStableHash(parts: Array<string | number | undefined | null>): string;
+export declare function inferSourceTitle(sourcePath: string): string;
+export declare function normalizeMarkdownText(text: string): string;
+export declare function parseLooseTimestamp(raw: string | undefined, fallback: number): number;
+export interface ParsedMarkdownRoleLine {
+    role: SourceActorRole;
+    rawRole: string;
+    text: string;
+    timestamp?: string;
+}
+export declare function parseMarkdownRoleLine(line: string): ParsedMarkdownRoleLine | null;
+export declare function parseLooseDateHeading(line: string): string | null;
+export declare function resolveTimestampWithContext(raw: string | undefined, fallback: number, currentDateHint?: string): number;
+export declare function buildEpisodeEnvelope(source: SourceDefinition, record: SourceAdapterRecord): BatchEpisodeEnvelope;
+//# sourceMappingURL=types.d.ts.map