cogmem 3.6.2

package/dist/store/DeepWriteCandidateStore.js

@@ -0,0 +1,290 @@
+import { randomUUID } from 'crypto';
+export class DeepWriteCandidateStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS deep_write_runs (
+        run_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        source_neuron_ids_json TEXT NOT NULL,
+        model_provider TEXT,
+        model_name TEXT,
+        mode TEXT NOT NULL,
+        prompt_hash TEXT NOT NULL,
+        output_hash TEXT NOT NULL,
+        status TEXT NOT NULL,
+        error TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS deep_write_candidates (
+        candidate_id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        candidate_type TEXT NOT NULL,
+        status TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        content_json TEXT NOT NULL,
+        evidence_json TEXT NOT NULL,
+        promotion_target_type TEXT,
+        promotion_target_id TEXT,
+        status_reason TEXT,
+        review_after INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY(run_id) REFERENCES deep_write_runs(run_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_deep_write_runs_project_created
+        ON deep_write_runs(project_id, created_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_deep_write_candidates_run
+        ON deep_write_candidates(run_id);
+
+      CREATE INDEX IF NOT EXISTS idx_deep_write_candidates_status
+        ON deep_write_candidates(status, candidate_type);
+    `);
+        this.ensureColumn('deep_write_candidates', 'status_reason', 'TEXT');
+        this.ensureColumn('deep_write_candidates', 'review_after', 'INTEGER');
+        this.ensureColumn('deep_write_candidates', 'updated_at', 'INTEGER');
+        this.db.exec(`
+      UPDATE deep_write_candidates
+      SET updated_at = created_at
+      WHERE updated_at IS NULL
+    `);
+    }
+    insertRun(input) {
+        const record = {
+            ...input,
+            runId: input.runId || randomUUID(),
+            createdAt: input.createdAt ?? Date.now()
+        };
+        this.db.prepare(`
+      INSERT INTO deep_write_runs (
+        run_id, project_id, session_id, source_neuron_ids_json, model_provider,
+        model_name, mode, prompt_hash, output_hash, status, error, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(record.runId, record.projectId || null, record.sessionId || null, JSON.stringify(record.sourceNeuronIds), record.modelProvider || null, record.modelName || null, record.mode, record.promptHash, record.outputHash, record.status, record.error || null, record.createdAt);
+        return record;
+    }
+    insertCandidates(inputs) {
+        const records = inputs.map((input) => ({
+            ...input,
+            candidateId: input.candidateId || randomUUID(),
+            createdAt: input.createdAt ?? Date.now(),
+            updatedAt: input.createdAt ?? Date.now()
+        }));
+        const stmt = this.db.prepare(`
+      INSERT INTO deep_write_candidates (
+        candidate_id, run_id, candidate_type, status, confidence, content_json,
+        evidence_json, promotion_target_type, promotion_target_id, status_reason,
+        review_after, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        this.db.transaction(() => {
+            for (const record of records) {
+                stmt.run(record.candidateId, record.runId, record.candidateType, record.status, record.confidence, JSON.stringify(record.content), JSON.stringify(record.evidence), record.promotionTargetType || null, record.promotionTargetId || null, record.statusReason || null, record.reviewAfter ?? null, record.createdAt, record.updatedAt);
+            }
+        })();
+        return records;
+    }
+    getRun(runId) {
+        const row = this.db.prepare(`
+      SELECT *
+      FROM deep_write_runs
+      WHERE run_id = ?
+    `).get(runId);
+        return row ? this.mapRun(row) : null;
+    }
+    listCandidatesByRun(runId) {
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM deep_write_candidates
+      WHERE run_id = ?
+      ORDER BY created_at ASC, candidate_id ASC
+    `).all(runId);
+        return rows.map((row) => this.mapCandidate(row));
+    }
+    getCandidate(candidateId) {
+        const row = this.db.prepare(`
+      SELECT *
+      FROM deep_write_candidates
+      WHERE candidate_id = ?
+    `).get(candidateId);
+        return row ? this.mapCandidate(row) : null;
+    }
+    listCandidatesByStatus(statuses, options) {
+        if (statuses.length === 0)
+            return [];
+        const params = [...statuses];
+        let sql = `
+      SELECT *
+      FROM deep_write_candidates
+      WHERE status IN (${statuses.map(() => '?').join(', ')})
+    `;
+        if (options?.candidateTypes?.length) {
+            sql += ` AND candidate_type IN (${options.candidateTypes.map(() => '?').join(', ')})`;
+            params.push(...options.candidateTypes);
+        }
+        sql += ` ORDER BY created_at ASC, candidate_id ASC LIMIT ?`;
+        params.push(options?.limit ?? 100);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.mapCandidate(row));
+    }
+    listCandidates(options = {}) {
+        const params = [];
+        const conditions = [];
+        let sql = `
+      SELECT c.*
+      FROM deep_write_candidates c
+      JOIN deep_write_runs r ON r.run_id = c.run_id
+    `;
+        if (options.statuses?.length) {
+            conditions.push(`c.status IN (${options.statuses.map(() => '?').join(', ')})`);
+            params.push(...options.statuses);
+        }
+        if (options.candidateTypes?.length) {
+            conditions.push(`c.candidate_type IN (${options.candidateTypes.map(() => '?').join(', ')})`);
+            params.push(...options.candidateTypes);
+        }
+        if (options.projectId) {
+            conditions.push('r.project_id = ?');
+            params.push(options.projectId);
+        }
+        if (options.runId) {
+            conditions.push('c.run_id = ?');
+            params.push(options.runId);
+        }
+        if (conditions.length)
+            sql += ` WHERE ${conditions.join(' AND ')}`;
+        sql += ` ORDER BY c.created_at ASC, c.candidate_id ASC LIMIT ?`;
+        params.push(options.limit ?? 100);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.mapCandidate(row));
+    }
+    countCandidates(options = {}) {
+        const params = [];
+        const conditions = [];
+        let sql = `
+      SELECT COUNT(*) AS count
+      FROM deep_write_candidates c
+      JOIN deep_write_runs r ON r.run_id = c.run_id
+    `;
+        if (options.statuses?.length) {
+            conditions.push(`c.status IN (${options.statuses.map(() => '?').join(', ')})`);
+            params.push(...options.statuses);
+        }
+        if (options.candidateTypes?.length) {
+            conditions.push(`c.candidate_type IN (${options.candidateTypes.map(() => '?').join(', ')})`);
+            params.push(...options.candidateTypes);
+        }
+        if (options.projectId) {
+            conditions.push('r.project_id = ?');
+            params.push(options.projectId);
+        }
+        if (options.runId) {
+            conditions.push('c.run_id = ?');
+            params.push(options.runId);
+        }
+        if (conditions.length)
+            sql += ` WHERE ${conditions.join(' AND ')}`;
+        const row = this.db.prepare(sql).get(...params);
+        return row?.count || 0;
+    }
+    updateCandidateStatus(candidateId, status, promotionTarget) {
+        this.db.prepare(`
+      UPDATE deep_write_candidates
+      SET status = ?,
+          promotion_target_type = COALESCE(?, promotion_target_type),
+          promotion_target_id = COALESCE(?, promotion_target_id),
+          status_reason = COALESCE(?, status_reason),
+          review_after = COALESCE(?, review_after),
+          updated_at = ?
+      WHERE candidate_id = ?
+    `).run(status, promotionTarget?.type || null, promotionTarget?.id || null, promotionTarget?.reason || null, promotionTarget?.reviewAfter ?? null, promotionTarget?.updatedAt ?? Date.now(), candidateId);
+    }
+    updateCandidateReviewData(candidateId, input) {
+        this.db.prepare(`
+      UPDATE deep_write_candidates
+      SET content_json=?, evidence_json=?, promotion_target_type=?, promotion_target_id=?,
+          status=?, status_reason=?, review_after=?, updated_at=?
+      WHERE candidate_id=?
+    `).run(JSON.stringify(input.content), JSON.stringify(input.evidence), input.promotionTargetType || null, input.promotionTargetId || null, input.status, input.statusReason, input.reviewAfter ?? null, input.updatedAt ?? Date.now(), candidateId);
+    }
+    expireNeedsConfirmation(input) {
+        const params = [input.before];
+        let sql = `
+      SELECT c.candidate_id
+      FROM deep_write_candidates c
+      JOIN deep_write_runs r ON r.run_id = c.run_id
+      WHERE c.status = 'needs_confirmation'
+        AND COALESCE(c.updated_at, c.created_at) < ?
+    `;
+        if (input.projectId) {
+            sql += ' AND r.project_id = ?';
+            params.push(input.projectId);
+        }
+        sql += ' ORDER BY COALESCE(c.updated_at, c.created_at) ASC, c.candidate_id ASC LIMIT ?';
+        params.push(input.limit ?? 1000);
+        const rows = this.db.prepare(sql).all(...params);
+        const now = input.now ?? Date.now();
+        this.db.transaction(() => {
+            for (const row of rows) {
+                this.updateCandidateStatus(row.candidate_id, 'superseded', {
+                    type: 'review_queue_expiry',
+                    id: row.candidate_id,
+                    reason: 'needs_confirmation_ttl_expired',
+                    updatedAt: now,
+                });
+            }
+        })();
+        return {
+            expired: rows.length,
+            candidateIds: rows.map((row) => row.candidate_id),
+            cutoff: input.before,
+        };
+    }
+    mapRun(row) {
+        return {
+            runId: row.run_id,
+            projectId: row.project_id || undefined,
+            sessionId: row.session_id || undefined,
+            sourceNeuronIds: JSON.parse(row.source_neuron_ids_json || '[]'),
+            modelProvider: row.model_provider || undefined,
+            modelName: row.model_name || undefined,
+            mode: row.mode,
+            promptHash: row.prompt_hash,
+            outputHash: row.output_hash,
+            status: row.status,
+            error: row.error || undefined,
+            createdAt: row.created_at
+        };
+    }
+    mapCandidate(row) {
+        return {
+            candidateId: row.candidate_id,
+            runId: row.run_id,
+            candidateType: row.candidate_type,
+            status: row.status,
+            confidence: row.confidence,
+            content: JSON.parse(row.content_json || '{}'),
+            evidence: JSON.parse(row.evidence_json || '[]'),
+            promotionTargetType: row.promotion_target_type || undefined,
+            promotionTargetId: row.promotion_target_id || undefined,
+            statusReason: row.status_reason || undefined,
+            reviewAfter: row.review_after ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at || row.created_at
+        };
+    }
+    ensureColumn(table, column, definition) {
+        const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        if (columns.some((item) => item.name === column))
+            return;
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    }
+}

package/dist/store/DeterministicEmbedder.d.ts

@@ -0,0 +1,10 @@
+import { Embedder } from './Embedder.js';
+export declare class DeterministicEmbedder extends Embedder {
+    private readonly dimension;
+    constructor(dimension?: number);
+    warmup(): Promise<void>;
+    embed(text: string): Promise<number[]>;
+    isReady(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=DeterministicEmbedder.d.ts.map

package/dist/store/DeterministicEmbedder.js

@@ -0,0 +1,24 @@
+import { Embedder } from './Embedder.js';
+import { config } from '../utils/Config.js';
+export class DeterministicEmbedder extends Embedder {
+    dimension;
+    constructor(dimension = config.vector.dimension) {
+        super();
+        this.dimension = dimension;
+    }
+    async warmup() {
+        this.isLoaded = true;
+        this.isWarmedUp = true;
+    }
+    async embed(text) {
+        const seed = Array.from(text).reduce((sum, ch) => sum + ch.charCodeAt(0), 0);
+        return Array.from({ length: this.dimension }, (_, index) => (((seed + index * 11) % 101) / 50.5) - 1);
+    }
+    isReady() {
+        return true;
+    }
+    dispose() {
+        this.isLoaded = false;
+        this.isWarmedUp = false;
+    }
+}

package/dist/store/DreamLedgerStore.d.ts

@@ -0,0 +1,22 @@
+import type Database from 'bun:sqlite';
+export interface DreamBacklogStatus {
+    projectId?: string;
+    rawEventCount: number;
+    dreamedRawCount: number;
+    undreamedRawCount: number;
+    dreamCoverageRate: number;
+    lastDreamedGlobalSeq?: number;
+    lastDreamedAt?: number;
+    updatedAt?: number;
+}
+export declare class DreamLedgerStore {
+    private readonly db;
+    constructor(db: Database);
+    getStatus(projectId?: string): DreamBacklogStatus;
+    markDreamed(projectId: string | undefined, globalSeq: number, dreamedAt?: number): DreamBacklogStatus;
+    private initializeSchema;
+    private getState;
+    private countRawEvents;
+    private projectKey;
+}
+//# sourceMappingURL=DreamLedgerStore.d.ts.map

package/dist/store/DreamLedgerStore.js

@@ -0,0 +1,84 @@
+export class DreamLedgerStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initializeSchema();
+    }
+    getStatus(projectId) {
+        const state = this.getState(projectId);
+        const lastDreamedGlobalSeq = state?.lastDreamedGlobalSeq;
+        const rawEventCount = this.countRawEvents(projectId);
+        const dreamedRawCount = lastDreamedGlobalSeq === undefined
+            ? 0
+            : this.countRawEvents(projectId, { maxGlobalSeq: lastDreamedGlobalSeq });
+        const undreamedRawCount = Math.max(0, rawEventCount - dreamedRawCount);
+        return {
+            projectId,
+            rawEventCount,
+            dreamedRawCount,
+            undreamedRawCount,
+            dreamCoverageRate: rawEventCount === 0 ? 1 : dreamedRawCount / rawEventCount,
+            lastDreamedGlobalSeq,
+            lastDreamedAt: state?.lastDreamedAt,
+            updatedAt: state?.updatedAt,
+        };
+    }
+    markDreamed(projectId, globalSeq, dreamedAt = Date.now()) {
+        const key = this.projectKey(projectId);
+        this.db.prepare(`
+      INSERT INTO dream_ledger_state (project_key, project_id, last_dreamed_global_seq, last_dreamed_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(project_key) DO UPDATE SET
+        last_dreamed_global_seq = excluded.last_dreamed_global_seq,
+        last_dreamed_at = excluded.last_dreamed_at,
+        updated_at = excluded.updated_at
+    `).run(key, projectId || null, globalSeq, dreamedAt, dreamedAt);
+        return this.getStatus(projectId);
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS dream_ledger_state (
+        project_key TEXT PRIMARY KEY,
+        project_id TEXT,
+        last_dreamed_global_seq INTEGER,
+        last_dreamed_at INTEGER,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+    }
+    getState(projectId) {
+        const row = this.db.prepare(`
+      SELECT last_dreamed_global_seq, last_dreamed_at, updated_at
+      FROM dream_ledger_state
+      WHERE project_key = ?
+    `).get(this.projectKey(projectId));
+        if (!row)
+            return null;
+        return {
+            lastDreamedGlobalSeq: row.last_dreamed_global_seq || undefined,
+            lastDreamedAt: row.last_dreamed_at || undefined,
+            updatedAt: row.updated_at || undefined,
+        };
+    }
+    countRawEvents(projectId, options = {}) {
+        const conditions = [`event_type = 'RAW_EVENT_RECORDED'`];
+        const params = [];
+        if (projectId) {
+            conditions.push('project_id = ?');
+            params.push(projectId);
+        }
+        if (options.maxGlobalSeq !== undefined) {
+            conditions.push('global_seq <= ?');
+            params.push(options.maxGlobalSeq);
+        }
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM memory_events
+      WHERE ${conditions.join(' AND ')}
+    `).get(...params);
+        return row?.count || 0;
+    }
+    projectKey(projectId) {
+        return projectId || '__global__';
+    }
+}

package/dist/store/Embedder.d.ts

@@ -0,0 +1,14 @@
+import type { EmbeddingConfig } from '../types/index.js';
+export declare class Embedder {
+    private model;
+    private config;
+    isWarmedUp: boolean;
+    isLoaded: boolean;
+    constructor(config?: Partial<EmbeddingConfig>);
+    warmup(): Promise<void>;
+    embed(text: string): Promise<number[]>;
+    isReady(): boolean;
+    dispose(): void;
+    getConfig(): EmbeddingConfig;
+}
+//# sourceMappingURL=Embedder.d.ts.map

package/dist/store/Embedder.js

@@ -0,0 +1,52 @@
+// ============================================
+// 嵌入模型 - @xenova/transformers 实现
+// ============================================
+async function loadTransformers() {
+    return await import('@xenova/transformers');
+}
+function configureEnv(transformers, config) {
+    transformers.env.allowLocalModels = false;
+    transformers.env.useBrowserCache = false;
+    transformers.env.allowRemoteModels = true;
+    transformers.env.cacheDir = config.cacheDir;
+}
+export class Embedder {
+    model = null;
+    config;
+    isWarmedUp = false;
+    isLoaded = false;
+    constructor(config = {}) {
+        this.config = {
+            model: config.model || 'all-MiniLM-L6-v2',
+            cacheDir: config.cacheDir || `${process.env.HOME || '/tmp'}/.cache/cogmem/embeddings`,
+            quantized: config.quantized ?? true,
+            maxSequenceLength: config.maxSequenceLength || 512
+        };
+    }
+    async warmup() {
+        if (this.isWarmedUp)
+            return;
+        const transformers = await loadTransformers();
+        configureEnv(transformers, this.config);
+        this.model = await transformers.pipeline('feature-extraction', this.config.model);
+        this.isWarmedUp = true;
+        this.isLoaded = true;
+    }
+    async embed(text) {
+        if (!this.model)
+            await this.warmup();
+        const result = await this.model(text, { pooling: 'mean', normalize: true });
+        return Array.from(result.data);
+    }
+    isReady() {
+        return this.isLoaded;
+    }
+    dispose() {
+        this.model = null;
+        this.isLoaded = false;
+        this.isWarmedUp = false;
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/dist/store/EmbedderFactory.d.ts

@@ -0,0 +1,12 @@
+import { Embedder } from './Embedder.js';
+import { ModelRegistry } from '../models/ModelRegistry.js';
+export type EmbeddingBackendId = 'deterministic_local' | 'transformers_remote' | 'openai_compatible';
+export interface EmbeddingBackendInfo {
+    backendId: EmbeddingBackendId;
+    requiresModelSetup: boolean;
+    mayDownloadModels: boolean;
+}
+export declare function resolveEmbeddingBackendId(modelRegistry?: ModelRegistry): EmbeddingBackendId;
+export declare function getEmbeddingBackendInfo(backendId?: EmbeddingBackendId): EmbeddingBackendInfo;
+export declare function createConfiguredEmbedder(vectorDimension?: number, modelRegistry?: ModelRegistry): Embedder;
+//# sourceMappingURL=EmbedderFactory.d.ts.map

package/dist/store/EmbedderFactory.js

@@ -0,0 +1,51 @@
+import { Embedder } from './Embedder.js';
+import { DeterministicEmbedder } from './DeterministicEmbedder.js';
+import { ModelRegistry } from '../models/ModelRegistry.js';
+export function resolveEmbeddingBackendId(modelRegistry) {
+    const role = modelRegistry?.getRoleConfig('embedding');
+    if (role?.provider === 'openai_compatible') {
+        return 'openai_compatible';
+    }
+    return 'deterministic_local';
+}
+export function getEmbeddingBackendInfo(backendId = resolveEmbeddingBackendId()) {
+    if (backendId === 'openai_compatible') {
+        return { backendId, requiresModelSetup: false, mayDownloadModels: false };
+    }
+    return backendId === 'transformers_remote'
+        ? { backendId, requiresModelSetup: false, mayDownloadModels: true }
+        : { backendId, requiresModelSetup: false, mayDownloadModels: false };
+}
+class ModelRegistryEmbedder extends Embedder {
+    embedFn;
+    constructor(embedFn) {
+        super();
+        this.embedFn = embedFn;
+    }
+    async warmup() {
+        this.isLoaded = true;
+        this.isWarmedUp = true;
+    }
+    async embed(text) {
+        if (!this.isWarmedUp) {
+            await this.warmup();
+        }
+        return this.embedFn(text);
+    }
+    isReady() {
+        return this.isLoaded;
+    }
+    dispose() {
+        this.isLoaded = false;
+        this.isWarmedUp = false;
+    }
+}
+export function createConfiguredEmbedder(vectorDimension, modelRegistry = ModelRegistry.defaults()) {
+    const backendId = resolveEmbeddingBackendId(modelRegistry);
+    if (backendId === 'openai_compatible') {
+        return new ModelRegistryEmbedder(modelRegistry.getEmbedder());
+    }
+    return backendId === 'transformers_remote'
+        ? new Embedder()
+        : new DeterministicEmbedder(vectorDimension);
+}