autosnippet 3.3.7 → 3.3.9

package/dist/lib/agent/memory/MemoryEmbeddingStore.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MemoryEmbeddingStore — 向量嵌入的 JSON sidecar 存储
+ *
+ * 将 Agent Memory 的向量嵌入从 SQLite BLOB 迁移到独立 JSON 文件，
+ * 与 Knowledge 侧 HNSW `.asvec` 的设计理念对齐：
+ * **结构化数据存 SQLite，向量存独立文件。**
+ *
+ * 设计:
+ *   - 内存 Map<id, number[]> 缓存，启动时一次性加载
+ *   - 写入时更新内存 + debounced flush 到 JSON
+ *   - 崩溃丢失可通过 embedAllMemories() backfill 恢复
+ *
+ * 文件位置: .autosnippet/context/memory_embeddings.json
+ *
+ * @module MemoryEmbeddingStore
+ */
+export declare class MemoryEmbeddingStore {
+    #private;
+    /**
+     * @param projectRoot 项目根目录
+     * @param opts.filePath 覆盖默认文件路径 (测试用)
+     */
+    constructor(projectRoot: string, opts?: {
+        filePath?: string;
+    });
+    /** 获取单条 embedding */
+    get(id: string): number[] | null;
+    /** 设置单条 embedding */
+    set(id: string, embedding: number[]): void;
+    /** 批量设置 embeddings */
+    batchSet(entries: Array<{
+        id: string;
+        embedding: number[];
+    }>): number;
+    /** 删除单条 embedding */
+    delete(id: string): boolean;
+    /** 检查是否有 embedding */
+    has(id: string): boolean;
+    /** 返回所有缺少 embedding 的 ID (给定候选 ID 列表) */
+    getMissingIds(candidateIds: string[]): string[];
+    /** 缓存大小 */
+    get size(): number;
+    /** 清除所有 embeddings (用于重建) */
+    clear(): void;
+    /** 立即刷写到磁盘 (shutdown / 测试用) */
+    flushSync(): void;
+    /** GC: 移除不在给定 ID 集合中的 embeddings */
+    gc(activeIds: Set<string>): number;
+}

package/dist/lib/agent/memory/MemoryEmbeddingStore.js

@@ -0,0 +1,159 @@
+/**
+ * MemoryEmbeddingStore — 向量嵌入的 JSON sidecar 存储
+ *
+ * 将 Agent Memory 的向量嵌入从 SQLite BLOB 迁移到独立 JSON 文件，
+ * 与 Knowledge 侧 HNSW `.asvec` 的设计理念对齐：
+ * **结构化数据存 SQLite，向量存独立文件。**
+ *
+ * 设计:
+ *   - 内存 Map<id, number[]> 缓存，启动时一次性加载
+ *   - 写入时更新内存 + debounced flush 到 JSON
+ *   - 崩溃丢失可通过 embedAllMemories() backfill 恢复
+ *
+ * 文件位置: .autosnippet/context/memory_embeddings.json
+ *
+ * @module MemoryEmbeddingStore
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/** debounce flush 延迟 (ms) */
+const FLUSH_DELAY_MS = 2000;
+export class MemoryEmbeddingStore {
+    /** 内存缓存: id → embedding vector */
+    #cache = new Map();
+    /** JSON 文件路径 */
+    #filePath;
+    /** debounce timer */
+    #flushTimer = null;
+    /** dirty flag */
+    #dirty = false;
+    /**
+     * @param projectRoot 项目根目录
+     * @param opts.filePath 覆盖默认文件路径 (测试用)
+     */
+    constructor(projectRoot, opts) {
+        this.#filePath =
+            opts?.filePath ?? join(projectRoot, '.autosnippet', 'context', 'memory_embeddings.json');
+        this.#load();
+    }
+    /** 获取单条 embedding */
+    get(id) {
+        return this.#cache.get(id) ?? null;
+    }
+    /** 设置单条 embedding */
+    set(id, embedding) {
+        this.#cache.set(id, embedding);
+        this.#scheduleDirtyFlush();
+    }
+    /** 批量设置 embeddings */
+    batchSet(entries) {
+        let count = 0;
+        for (const { id, embedding } of entries) {
+            this.#cache.set(id, embedding);
+            count++;
+        }
+        if (count > 0) {
+            this.#scheduleDirtyFlush();
+        }
+        return count;
+    }
+    /** 删除单条 embedding */
+    delete(id) {
+        const existed = this.#cache.delete(id);
+        if (existed) {
+            this.#scheduleDirtyFlush();
+        }
+        return existed;
+    }
+    /** 检查是否有 embedding */
+    has(id) {
+        return this.#cache.has(id);
+    }
+    /** 返回所有缺少 embedding 的 ID (给定候选 ID 列表) */
+    getMissingIds(candidateIds) {
+        return candidateIds.filter((id) => !this.#cache.has(id));
+    }
+    /** 缓存大小 */
+    get size() {
+        return this.#cache.size;
+    }
+    /** 清除所有 embeddings (用于重建) */
+    clear() {
+        this.#cache.clear();
+        this.#scheduleDirtyFlush();
+    }
+    /** 立即刷写到磁盘 (shutdown / 测试用) */
+    flushSync() {
+        if (this.#flushTimer) {
+            clearTimeout(this.#flushTimer);
+            this.#flushTimer = null;
+        }
+        if (!this.#dirty) {
+            return;
+        }
+        this.#writeFile();
+        this.#dirty = false;
+    }
+    /** GC: 移除不在给定 ID 集合中的 embeddings */
+    gc(activeIds) {
+        let removed = 0;
+        for (const id of this.#cache.keys()) {
+            if (!activeIds.has(id)) {
+                this.#cache.delete(id);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            this.#scheduleDirtyFlush();
+        }
+        return removed;
+    }
+    // ═══════════════════════════════════════════════════════════
+    // Private
+    // ═══════════════════════════════════════════════════════════
+    #load() {
+        try {
+            if (existsSync(this.#filePath)) {
+                const raw = readFileSync(this.#filePath, 'utf-8');
+                const data = JSON.parse(raw);
+                for (const [id, vec] of Object.entries(data)) {
+                    if (Array.isArray(vec)) {
+                        this.#cache.set(id, vec);
+                    }
+                }
+            }
+        }
+        catch {
+            // 文件不存在或解析失败 → 空缓存，后续 backfill 会重建
+        }
+    }
+    #writeFile() {
+        try {
+            const dir = dirname(this.#filePath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const obj = {};
+            for (const [id, vec] of this.#cache) {
+                obj[id] = vec;
+            }
+            writeFileSync(this.#filePath, JSON.stringify(obj), 'utf-8');
+        }
+        catch {
+            // 写入失败不阻塞运行时；下次 flush 或 backfill 会重试
+        }
+    }
+    #scheduleDirtyFlush() {
+        this.#dirty = true;
+        if (this.#flushTimer) {
+            return; // 已有 pending timer
+        }
+        this.#flushTimer = setTimeout(() => {
+            this.#flushTimer = null;
+            if (this.#dirty) {
+                this.#writeFile();
+                this.#dirty = false;
+            }
+        }, FLUSH_DELAY_MS);
+    }
+}

package/dist/lib/agent/memory/MemoryRetriever.d.ts

@@ -10,6 +10,7 @@
  *
  * @module MemoryRetriever
  */
+import type { MemoryEmbeddingStore } from './MemoryEmbeddingStore.js';
 import type { DeserializedMemory } from './MemoryStore.js';
 import { MemoryStore } from './MemoryStore.js';
 /** 带评分的记忆检索结果 */
@@ -49,6 +50,7 @@ export declare class MemoryRetriever {
     /** @param [opts.embeddingFn] 向量嵌入函数 (异步) */
     constructor(store: MemoryStore, opts?: {
         embeddingFn?: EmbeddingFn;
+        embeddingStore?: MemoryEmbeddingStore;
     });
     /**
      * 综合检索: recency × importance × relevance

package/dist/lib/agent/memory/MemoryRetriever.js

@@ -25,10 +25,13 @@ export class MemoryRetriever {
     #store;
     /** 向量嵌入函数 */
     #embeddingFn;
+    /** 向量嵌入存储 (JSON sidecar) */
+    #embeddingStore;
     /** @param [opts.embeddingFn] 向量嵌入函数 (异步) */
     constructor(store, opts = {}) {
         this.#store = store;
         this.#embeddingFn = typeof opts.embeddingFn === 'function' ? opts.embeddingFn : null;
+        this.#embeddingStore = opts.embeddingStore ?? null;
     }
     // ═══════════════════════════════════════════════════════════
     // 综合检索
@@ -71,14 +74,15 @@ export class MemoryRetriever {
             const importance = (m.importance || 5) / 10;
             // Relevance: 词汇相关性 (lexical)
             const lexicalRelevance = MemoryRetriever.#computeRelevance(lowerQuery, queryTokens, m.content);
-            // 向量相关性: 对有 embedding 的记忆计算余弦相似度
+            // 向量相关性: 从 embeddingStore 查找 embedding 做余弦相似度
             const deserialized = MemoryStore.deserialize(m);
             let vectorRelevance = 0;
-            if (queryVec && deserialized.embedding) {
-                vectorRelevance = Math.max(0, cosineSimilarity(queryVec, deserialized.embedding));
+            const storedEmbedding = this.#embeddingStore?.get(m.id) ?? null;
+            if (queryVec && storedEmbedding) {
+                vectorRelevance = Math.max(0, cosineSimilarity(queryVec, storedEmbedding));
             }
             // 混合相关性: 有向量时 0.6 * vector + 0.4 * lexical，否则纯 lexical
-            const relevance = queryVec && deserialized.embedding
+            const relevance = queryVec && storedEmbedding
                 ? 0.6 * vectorRelevance + 0.4 * lexicalRelevance
                 : lexicalRelevance;
             const score = WEIGHT_RECENCY * recency + WEIGHT_IMPORTANCE * importance + WEIGHT_RELEVANCE * relevance;
@@ -199,18 +203,28 @@ export class MemoryRetriever {
      * @returns 成功嵌入的记忆数
      */
     async embedAllMemories(batchSize = 20) {
-        if (!this.#embeddingFn) {
+        if (!this.#embeddingFn || !this.#embeddingStore) {
             return 0;
         }
-        const missing = this.#store.getWithoutEmbedding(batchSize);
-        if (missing.length === 0) {
+        // 从 MemoryStore 获取所有活跃记忆 ID，找出 embeddingStore 中缺失的
+        const allActive = this.#store.getAllActive();
+        const allIds = allActive.map((m) => m.id);
+        const missingIds = this.#embeddingStore.getMissingIds(allIds);
+        if (missingIds.length === 0) {
             return 0;
         }
+        // 取前 batchSize 条
+        const batch = missingIds.slice(0, batchSize);
+        const contentMap = new Map(allActive.map((m) => [m.id, m.content]));
         const entries = [];
-        for (const item of missing) {
+        for (const id of batch) {
+            const content = contentMap.get(id);
+            if (!content) {
+                continue;
+            }
             try {
-                const vec = await this.#embeddingFn(item.content);
-                entries.push({ id: item.id, embedding: vec });
+                const vec = await this.#embeddingFn(content);
+                entries.push({ id, embedding: vec });
             }
             catch {
                 // 单条失败不阻塞
@@ -219,7 +233,7 @@ export class MemoryRetriever {
         if (entries.length === 0) {
             return 0;
         }
-        return this.#store.batchUpdateEmbeddings(entries);
+        return this.#embeddingStore.batchSet(entries);
     }
     /**
      * 使用嵌入函数计算语义相关性 (余弦相似度)

package/dist/lib/agent/memory/MemoryStore.d.ts

@@ -1,10 +1,8 @@
 /**
- * MemoryStore — 持久化记忆 SQLite 存储层
+ * MemoryStore — 持久化记忆 SQLite 存储层（Drizzle 类型安全版）
  *
  * 从 PersistentMemory.js 提取的 CRUD + SQL 基础设施。
  * 负责:
- *   - 表结构确保 (#ensureTable)
- *   - SQL 预编译 (#prepareStatements)
  *   - 基本 CRUD: add, update, delete, get
  *   - 批量查询: getAllActive, size, getStats
  *   - 访问计数: touchAccess
@@ -13,8 +11,9 @@
  *   - 统计: getStats, clearBootstrapMemories
  *
  * 设计原则:
- *   - 拥有 #db 和 #stmts，其他组件通过 MemoryStore 访问数据
- *   - update() 使用动态 SQL 但通过 named parameters 防注入
+ *   - 大部分操作通过 Drizzle 类型安全 API
+ *   - update() 使用 Drizzle 类型安全 partial update
+ *   - embedding 已迁移至 MemoryEmbeddingStore (JSON sidecar)
  *   - 数据序列化/反序列化统一在此层处理
  *
  * @module MemoryStore
@@ -34,7 +33,7 @@ export interface SqliteStatement {
     get(...params: unknown[]): Record<string, unknown> | undefined;
     all(...params: unknown[]): Record<string, unknown>[];
 }
-/** 数据库行 (raw row from SQLite) */
+/** 数据库行 (raw row from SQLite — 保持向后兼容) */
 export interface MemoryRow {
     id: string;
     type: string;
@@ -52,8 +51,6 @@ export interface MemoryRow {
     source_evidence: string | null;
     bootstrap_session: string | null;
     tags: string;
-    /** 向量嵌入 (Float32Array BLOB) */
-    embedding: Buffer | null;
     /** findSimilar 附加字段 */
     similarity?: number;
     related_memories_raw?: string;
@@ -76,8 +73,6 @@ export interface DeserializedMemory {
     sourceEvidence: string | null;
     bootstrapSession: string | null;
     tags: string[];
-    /** 向量嵌入 (Float32Array) */
-    embedding: number[] | null;
 }
 /** 添加记忆时的输入 */
 export interface MemoryInput {
@@ -91,8 +86,6 @@ export interface MemoryInput {
     sourceEvidence?: string | null;
     bootstrapSession?: string | null;
     tags?: string[];
-    /** 向量嵌入 */
-    embedding?: number[] | null;
 }
 /** 更新记忆时的字段 */
 export interface MemoryUpdates {
@@ -102,8 +95,6 @@ export interface MemoryUpdates {
     relatedEntities?: string[];
     relatedMemories?: string[];
     tags?: string[];
-    /** 向量嵌入 */
-    embedding?: number[] | null;
 }
 export declare class MemoryStore {
     #private;
@@ -119,7 +110,9 @@ export declare class MemoryStore {
         id: string;
         action: string;
     };
-    /** 更新已有记忆 */
+    /**
+     * 更新已有记忆
+     */
     update(id: string, updates: MemoryUpdates): boolean;
     /** 删除一条记忆 */
     delete(id: string): boolean;
@@ -184,30 +177,4 @@ export declare class MemoryStore {
     /** 反序列化数据库行为域对象 */
     static deserialize(row: MemoryRow): DeserializedMemory;
     static safeParseJSON<T>(str: string | null | undefined, fallback: T): T;
-    /**
-     * 更新单条记忆的向量嵌入
-     * @param id 记忆 ID
-     * @param embedding 向量数组
-     */
-    updateEmbedding(id: string, embedding: number[]): boolean;
-    /**
-     * 批量更新向量嵌入
-     * @param entries Array of { id, embedding }
-     */
-    batchUpdateEmbeddings(entries: Array<{
-        id: string;
-        embedding: number[];
-    }>): number;
-    /**
-     * 获取缺少向量嵌入的记忆 ID 和内容
-     * @param limit 最大返回数
-     */
-    getWithoutEmbedding(limit?: number): Array<{
-        id: string;
-        content: string;
-    }>;
-    /** 将 number[] 序列化为 Buffer (Float32Array → BLOB) */
-    static serializeEmbedding(embedding: number[]): Buffer;
-    /** 将 Buffer (BLOB) 反序列化为 number[] */
-    static deserializeEmbedding(blob: Buffer): number[];
 }