@qlingzzy/qling 1.0.0

package/dist/memory/cognitive-index.js

@@ -0,0 +1,265 @@
+// ============================================================
+// 轻灵 - Cognitive Index (v0.5)
+// 结合向量、图谱与经验蒸馏的综合认知引擎
+// ============================================================
+import Database from "better-sqlite3";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { existsSync } from "fs";
+export class CognitiveIndex {
+    db;
+    dbPath;
+    constructor(memoryDir) {
+        this.dbPath = path.join(memoryDir, "cognitive_knowledge.db");
+    }
+    async init() {
+        const dir = path.dirname(this.dbPath);
+        if (!existsSync(dir)) {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        this.db = new Database(this.dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        // 1. 向量存储表
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS embeddings (
+        id TEXT PRIMARY KEY,
+        content TEXT NOT NULL,
+        vector BLOB NOT NULL,
+        metadata TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+        // 2. 知识图谱表 (Entity-Relation-Entity)
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS kg_nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL, -- task, file, command, technology
+        label TEXT NOT NULL,
+        metadata TEXT,
+        last_seen INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS kg_edges (
+        source TEXT NOT NULL,
+        target TEXT NOT NULL,
+        relation TEXT NOT NULL, -- uses, writes, reads, part_of
+        weight REAL DEFAULT 1.0,
+        PRIMARY KEY (source, target, relation)
+      );
+    `);
+        // 3. 经验蒸馏表 (Best Practices)
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS distilled_practices (
+        id TEXT PRIMARY KEY,
+        task_pattern TEXT UNIQUE NOT NULL,
+        action_json TEXT NOT NULL, -- 成功执行的指令序列
+        context_json TEXT NOT NULL, -- 涉及的文件与前置条件
+        confidence REAL DEFAULT 1.0,
+        hit_count INTEGER DEFAULT 1,
+        created_at INTEGER NOT NULL
+      )
+    `);
+        // Ensure existing tables enforce the unique index on task_pattern
+        try {
+            this.db.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_distilled_practices_task_pattern ON distilled_practices(task_pattern);
+      `);
+        }
+        catch (err) {
+            console.warn("[CognitiveIndex] Failed to create unique index, attempting deduplication:", err.message);
+            try {
+                this.db.exec(`
+          DELETE FROM distilled_practices
+          WHERE id NOT IN (
+            SELECT MIN(id) FROM distilled_practices GROUP BY task_pattern
+          );
+        `);
+                this.db.exec(`
+          CREATE UNIQUE INDEX IF NOT EXISTS idx_distilled_practices_task_pattern ON distilled_practices(task_pattern);
+        `);
+            }
+            catch (dedupErr) {
+                console.error("[CognitiveIndex] Deduplication and index migration failed:", dedupErr.message);
+            }
+        }
+    }
+    // --- 向量操作 ---
+    upsertVector(entry, vector) {
+        const vectorBuffer = Buffer.from(new Float32Array(vector).buffer);
+        const stmt = this.db.prepare(`
+      INSERT INTO embeddings (id, content, vector, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        content = excluded.content,
+        vector = excluded.vector,
+        metadata = excluded.metadata
+    `);
+        stmt.run(entry.id, entry.content, vectorBuffer, JSON.stringify({ source: entry.source, importance: entry.importance }), entry.createdAt);
+    }
+    searchVector(queryVector, limit = 10) {
+        const all = this.db.prepare("SELECT * FROM embeddings").all();
+        const results = [];
+        for (const row of all) {
+            const vector = Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4));
+            const score = this.cosineSimilarity(queryVector, vector);
+            const metadata = JSON.parse(row.metadata || "{}");
+            results.push({
+                entry: {
+                    id: row.id,
+                    content: row.content,
+                    source: metadata.source || "unknown",
+                    importance: metadata.importance || 0.5,
+                    createdAt: row.created_at,
+                },
+                score,
+                source: "vector",
+            });
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+    // --- 知识图谱操作 ---
+    link(source, relation, target) {
+        const upsertNode = this.db.prepare(`
+      INSERT INTO kg_nodes (id, type, label, last_seen)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen
+    `);
+        const upsertEdge = this.db.prepare(`
+      INSERT INTO kg_edges (source, target, relation, weight)
+      VALUES (?, ?, ?, 1.0)
+      ON CONFLICT(source, target, relation) DO UPDATE SET weight = weight + 0.1
+    `);
+        const now = Date.now();
+        this.db.transaction(() => {
+            upsertNode.run(source.id, source.type, source.label, now);
+            upsertNode.run(target.id, target.type, target.label, now);
+            upsertEdge.run(source.id, target.id, relation);
+        })();
+    }
+    linkSessionToEntities(sessionId, summary, files, tasks) {
+        const sessionNode = { id: `session:${sessionId}`, type: "session", label: summary };
+        for (const file of files) {
+            const fileNode = { id: `file:${file}`, type: "file", label: file };
+            this.link(sessionNode, "modifies", fileNode);
+        }
+        for (const task of tasks) {
+            const taskNode = { id: `task:${task}`, type: "task", label: task };
+            this.link(sessionNode, "executes", taskNode);
+        }
+    }
+    // --- 经验蒸馏操作 ---
+    addPractice(practice) {
+        const stmt = this.db.prepare(`
+      INSERT INTO distilled_practices (id, task_pattern, action_json, context_json, confidence, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(task_pattern) DO UPDATE SET
+        hit_count = hit_count + 1,
+        confidence = (confidence + excluded.confidence) / 2.0
+    `);
+        stmt.run(practice.id, practice.task_pattern, JSON.stringify(practice.successful_commands), JSON.stringify(practice.files_involved), practice.confidence, Date.now());
+    }
+    getRelatedPractices(query) {
+        // 简单的关键词模式匹配，后期可升级为向量检索
+        return this.db.prepare(`
+      SELECT * FROM distilled_practices
+      WHERE task_pattern LIKE ?
+      ORDER BY confidence DESC, hit_count DESC
+      LIMIT 3
+    `).all(`%${query}%`);
+    }
+    // --- 符号索引相关操作 ---
+    upsertSymbolNode(fileRelativePath, symbol) {
+        const fileId = `file:${fileRelativePath}`;
+        const symbolId = `symbol:${fileRelativePath}:${symbol.name}`;
+        const now = Date.now();
+        const upsertNode = this.db.prepare(`
+      INSERT INTO kg_nodes (id, type, label, metadata, last_seen)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        label = excluded.label,
+        metadata = excluded.metadata,
+        last_seen = excluded.last_seen
+    `);
+        const upsertEdge = this.db.prepare(`
+      INSERT INTO kg_edges (source, target, relation, weight)
+      VALUES (?, ?, ?, 1.0)
+      ON CONFLICT(source, target, relation) DO UPDATE SET weight = weight + 0.1
+    `);
+        this.db.transaction(() => {
+            upsertNode.run(fileId, "file", fileRelativePath, null, now);
+            const meta = JSON.stringify({ kind: symbol.type, line: symbol.line, signature: symbol.signature });
+            upsertNode.run(symbolId, "symbol", symbol.name, meta, now);
+            upsertEdge.run(symbolId, fileId, "part_of");
+        })();
+    }
+    getSymbolsForFile(fileRelativePath) {
+        const fileId = `file:${fileRelativePath}`;
+        const stmt = this.db.prepare(`
+      SELECT n.id, n.label, n.metadata
+      FROM kg_nodes n
+      JOIN kg_edges e ON n.id = e.source
+      WHERE e.target = ? AND e.relation = 'part_of' AND n.type = 'symbol'
+    `);
+        const rows = stmt.all(fileId);
+        return rows.map((r) => {
+            const meta = JSON.parse(r.metadata || "{}");
+            return {
+                name: r.label,
+                type: meta.kind || "function",
+                line: meta.line || 0,
+                signature: meta.signature || "",
+            };
+        });
+    }
+    clearSymbolsForFile(fileRelativePath) {
+        const fileId = `file:${fileRelativePath}`;
+        this.db.transaction(() => {
+            this.db.prepare(`
+        DELETE FROM kg_edges
+        WHERE target = ? AND relation = 'part_of'
+      `).run(fileId);
+            this.db.prepare(`
+        DELETE FROM kg_nodes
+        WHERE id LIKE ? AND type = 'symbol'
+      `).run(`symbol:${fileRelativePath}:%`);
+        })();
+    }
+    getAllSymbols() {
+        if (!this.db)
+            return [];
+        const stmt = this.db.prepare(`
+      SELECT n.label, n.metadata, e.target
+      FROM kg_nodes n
+      JOIN kg_edges e ON n.id = e.source
+      WHERE n.type = 'symbol' AND e.relation = 'part_of'
+    `);
+        const rows = stmt.all();
+        return rows.map((r) => {
+            const meta = JSON.parse(r.metadata || "{}");
+            const file = r.target.startsWith("file:") ? r.target.substring(5) : r.target;
+            return {
+                file,
+                name: r.label,
+                type: meta.kind || "function",
+                line: meta.line || 0,
+                signature: meta.signature || "",
+            };
+        });
+    }
+    // --- 辅助工具 ---
+    cosineSimilarity(v1, v2) {
+        if (v1.length !== v2.length)
+            return 0;
+        let dotProduct = 0, normA = 0, normB = 0;
+        for (let i = 0; i < v1.length; i++) {
+            dotProduct += v1[i] * v2[i];
+            normA += v1[i] * v1[i];
+            normB += v2[i] * v2[i];
+        }
+        const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+        return isNaN(similarity) ? 0 : similarity;
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/memory/compactor.d.ts

@@ -0,0 +1,28 @@
+import type { PersistedEntry } from "../types.js";
+export interface CompactionResult {
+    before: number;
+    after: number;
+    removed: number;
+    merged: number;
+}
+export interface CompactionApplyResult {
+    entries: PersistedEntry[];
+    stats: CompactionResult;
+}
+export interface CompactorOptions {
+    maxEntries: number;
+    expireAgeMs: number;
+    expireMinImportance: number;
+    dedupSimilarityThreshold: number;
+}
+export declare class MemoryCompactor {
+    private options;
+    constructor(options?: Partial<CompactorOptions>);
+    compact(entries: PersistedEntry[]): CompactionResult;
+    compactWithEntries(entries: PersistedEntry[]): CompactionApplyResult;
+    private deduplicate;
+    private similarity;
+    private bigrams;
+    private capByImportance;
+}
+//# sourceMappingURL=compactor.d.ts.map

package/dist/memory/compactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactor.d.ts","sourceRoot":"","sources":["../../src/memory/compactor.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,EAAE,MAAM,CAAC;CAClC;AASD,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAmB;gBAEtB,OAAO,GAAE,OAAO,CAAC,gBAAgB,CAAM;IAInD,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,gBAAgB;IAIpD,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,qBAAqB;IAgCpE,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,eAAe;CAMxB"}

package/dist/memory/compactor.js

@@ -0,0 +1,92 @@
+// ============================================================
+// 轻灵 - Memory Compactor（记忆压缩）
+// 去重 + 过期 + 上限裁剪
+// ============================================================
+const DEFAULT_OPTIONS = {
+    maxEntries: 1000,
+    expireAgeMs: 90 * 24 * 60 * 60 * 1000,
+    expireMinImportance: 0.3,
+    dedupSimilarityThreshold: 0.8,
+};
+export class MemoryCompactor {
+    options;
+    constructor(options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    compact(entries) {
+        return this.compactWithEntries(entries).stats;
+    }
+    compactWithEntries(entries) {
+        const before = entries.length;
+        let removed = 0;
+        // 1. 过期清理
+        const now = Date.now();
+        const afterExpire = entries.filter((e) => {
+            const age = now - e.createdAt;
+            if (age > this.options.expireAgeMs && e.importance < this.options.expireMinImportance) {
+                removed++;
+                return false;
+            }
+            return true;
+        });
+        // 2. 去重合并
+        const deduped = this.deduplicate(afterExpire);
+        const merged = afterExpire.length - deduped.length;
+        // 3. 上限裁剪（按重要性排序，保留高重要性的）
+        const capped = this.capByImportance(deduped, this.options.maxEntries);
+        const afterCapRemoved = deduped.length - capped.length;
+        removed += afterCapRemoved;
+        return {
+            entries: capped,
+            stats: { before, after: capped.length, removed, merged },
+        };
+    }
+    // --- Private ---
+    deduplicate(entries) {
+        const kept = [];
+        for (const entry of entries) {
+            const duplicate = kept.find((k) => this.similarity(k.content, entry.content) >= this.options.dedupSimilarityThreshold);
+            if (duplicate) {
+                // keep the one with higher importance
+                if (entry.importance > duplicate.importance) {
+                    const idx = kept.indexOf(duplicate);
+                    kept[idx] = entry;
+                }
+            }
+            else {
+                kept.push(entry);
+            }
+        }
+        return kept;
+    }
+    similarity(a, b) {
+        // simple bigram similarity (0-1)
+        const bigramsA = this.bigrams(a.toLowerCase());
+        const bigramsB = this.bigrams(b.toLowerCase());
+        if (bigramsA.size === 0 && bigramsB.size === 0)
+            return 1;
+        if (bigramsA.size === 0 || bigramsB.size === 0)
+            return 0;
+        let intersection = 0;
+        for (const bg of bigramsA) {
+            if (bigramsB.has(bg))
+                intersection++;
+        }
+        const union = bigramsA.size + bigramsB.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
+    bigrams(text) {
+        const set = new Set();
+        for (let i = 0; i < text.length - 1; i++) {
+            set.add(text.slice(i, i + 2));
+        }
+        return set;
+    }
+    capByImportance(entries, max) {
+        if (entries.length <= max)
+            return entries;
+        return entries
+            .sort((a, b) => b.importance - a.importance)
+            .slice(0, max);
+    }
+}

package/dist/memory/consolidation.d.ts

@@ -0,0 +1,13 @@
+import type { PersistedEntry } from "../types.js";
+export interface MemoryOperation {
+    action: "ADD" | "UPDATE" | "DELETE" | "NOOP";
+    fact: string;
+    targetId?: string;
+    reason?: string;
+}
+export declare function consolidateMemoriesLLM(newCandidates: string[], existingMemories: PersistedEntry[], config: {
+    apiKey: string;
+    endpoint: string;
+    model: string;
+}): Promise<MemoryOperation[]>;
+//# sourceMappingURL=consolidation.d.ts.map

package/dist/memory/consolidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidation.d.ts","sourceRoot":"","sources":["../../src/memory/consolidation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA+BD,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,MAAM,EAAE,EACvB,gBAAgB,EAAE,cAAc,EAAE,EAClC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1D,OAAO,CAAC,eAAe,EAAE,CAAC,CAqD5B"}

package/dist/memory/consolidation.js

@@ -0,0 +1,77 @@
+import axios from "axios";
+const CONSOLIDATE_PROMPT = `你是一个记忆合并与冲突消解专家。请比对以下“新提取的候选记忆”和“已有的长期记忆”，消除冲突、冗余，并输出合并整理指令。
+
+合并原则：
+1. 冲突消解：若候选记忆与已有记忆存在矛盾（例如，已有记忆说“当前使用 python 3.12”，而新候选记忆说“项目已升级到 python 3.13”），应该将旧记忆标记为 DELETE（或用 UPDATE 修正它），不要保留过期的矛盾事实。
+2. 消除冗余：如果候选记忆的内容已经包含在已有记忆中，或者意义完全一致，则无需重复添加，标记为 NOOP。
+3. 新知识添加：若候选记忆是全新且不矛盾的信息，标记为 ADD。
+4. 旧知识删除：若已有记忆已被新的会话上下文判定为过时或无效，标记为 DELETE。
+
+请返回一个 JSON 数组，包含每个记忆的操作结果，格式如下：
+[
+  {
+    "action": "ADD",
+    "fact": "新事实描述"
+  },
+  {
+    "action": "UPDATE",
+    "targetId": "mem_xxx",
+    "fact": "修正后的事实描述",
+    "reason": "更新理由"
+  },
+  {
+    "action": "DELETE",
+    "targetId": "mem_yyy",
+    "reason": "删除理由"
+  }
+]
+
+请只返回 JSON 格式数据，不要包含 Markdown 格式标记或其他任何文本。`;
+export async function consolidateMemoriesLLM(newCandidates, existingMemories, config) {
+    if (newCandidates.length === 0)
+        return [];
+    if (!config.apiKey) {
+        // If no API key, default to ADD for all new candidates that are not exact matches.
+        const existingContents = new Set(existingMemories.map(e => e.content));
+        return newCandidates
+            .filter(c => !existingContents.has(c))
+            .map(c => ({ action: "ADD", fact: c }));
+    }
+    try {
+        const payloadInput = {
+            candidates: newCandidates,
+            existing: existingMemories.map(e => ({ id: e.id, fact: e.content })),
+        };
+        const resp = await axios.post(config.endpoint + "/chat/completions", {
+            model: config.model,
+            messages: [
+                { role: "system", content: CONSOLIDATE_PROMPT },
+                { role: "user", content: JSON.stringify(payloadInput) },
+            ],
+            max_tokens: 800,
+            temperature: 0.2,
+        }, {
+            headers: {
+                Authorization: "Bearer " + config.apiKey,
+                "Content-Type": "application/json",
+            },
+            timeout: 30_000,
+        });
+        const content = resp.data.choices?.[0]?.message?.content?.trim() ?? "";
+        const jsonMatch = content.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    catch (err) {
+        console.error("[MemoryConsolidation] LLM request failed, falling back to direct add:", err);
+    }
+    // Fallback
+    const existingContents = new Set(existingMemories.map(e => e.content));
+    return newCandidates
+        .filter(c => !existingContents.has(c))
+        .map(c => ({ action: "ADD", fact: c }));
+}

package/dist/memory/embedding.d.ts

@@ -0,0 +1,15 @@
+export interface EmbeddingOptions {
+    apiKey: string;
+    endpoint: string;
+    model: string;
+    dimensions?: number;
+}
+export declare class EmbeddingClient {
+    private client;
+    private model;
+    private dimensions?;
+    constructor(options: EmbeddingOptions);
+    getEmbedding(text: string): Promise<number[]>;
+    getEmbeddings(texts: string[]): Promise<number[][]>;
+}
+//# sourceMappingURL=embedding.d.ts.map

package/dist/memory/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/memory/embedding.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAAC,CAAS;gBAEhB,OAAO,EAAE,gBAAgB;IAY/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmB7C,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;CAmB1D"}

package/dist/memory/embedding.js

@@ -0,0 +1,59 @@
+// ============================================================
+// 轻灵 - Embedding 向量生成工具
+// 支持 OpenAI / DeepSeek 等主流 Embedding 接口
+// ============================================================
+import axios from "axios";
+export class EmbeddingClient {
+    client;
+    model;
+    dimensions;
+    constructor(options) {
+        this.model = options.model;
+        this.dimensions = options.dimensions;
+        this.client = axios.create({
+            baseURL: options.endpoint,
+            headers: {
+                Authorization: `Bearer ${options.apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+    }
+    async getEmbedding(text) {
+        try {
+            const resp = await this.client.post("/embeddings", {
+                model: this.model,
+                input: text,
+                dimensions: this.dimensions, // 仅部分模型支持
+            });
+            const embedding = resp.data.data?.[0]?.embedding;
+            if (!Array.isArray(embedding)) {
+                throw new Error("Invalid embedding response format");
+            }
+            return embedding;
+        }
+        catch (err) {
+            const msg = err.response?.data?.error?.message || err.message;
+            throw new Error(`Embedding failed: ${msg}`);
+        }
+    }
+    async getEmbeddings(texts) {
+        if (texts.length === 0)
+            return [];
+        try {
+            const resp = await this.client.post("/embeddings", {
+                model: this.model,
+                input: texts,
+                dimensions: this.dimensions,
+            });
+            const embeddings = resp.data.data?.map((d) => d.embedding);
+            if (!Array.isArray(embeddings)) {
+                throw new Error("Invalid embeddings response format");
+            }
+            return embeddings;
+        }
+        catch (err) {
+            const msg = err.response?.data?.error?.message || err.message;
+            throw new Error(`Batch embedding failed: ${msg}`);
+        }
+    }
+}

package/dist/memory/memory-llm-dream.d.ts

@@ -0,0 +1,3 @@
+import type { LLMDreamConfig } from "../types.js";
+export declare function extractDreamMemoriesLLM(transcript: string[], turnCount: number, config: LLMDreamConfig): Promise<string[]>;
+//# sourceMappingURL=memory-llm-dream.d.ts.map

package/dist/memory/memory-llm-dream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-llm-dream.d.ts","sourceRoot":"","sources":["../../src/memory/memory-llm-dream.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAelD,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,MAAM,EAAE,CAAC,CAwDnB"}

package/dist/memory/memory-llm-dream.js

@@ -0,0 +1,59 @@
+// ============================================================
+// 轻灵 - LLM 增强记忆提取
+// 用 LLM 从对话中提取结构化记忆，regex 为降级兜底
+// ============================================================
+import axios from "axios";
+import { extractDreamMemories } from "../memory.js";
+const DREAM_PROMPT = `你是一个记忆提取助手。从以下对话中提取值得长期记住的信息。
+
+提取规则：
+1. 项目决策（选用了什么技术/框架/方案）
+2. 文件路径（重要的源文件、配置文件）
+3. 用户偏好（编码风格、工具偏好）
+4. 错误模式（遇到的 bug 及其解决方案）
+5. 关键上下文（工作目录、环境信息）
+
+返回 JSON 数组，每个元素是一句简洁的陈述（不超过50字）。
+如果没有值得记忆的内容，返回空数组 []。
+只返回 JSON 数组，不要其他文字。`;
+export async function extractDreamMemoriesLLM(transcript, turnCount, config) {
+    if (!config.enabled || !config.apiKey) {
+        return extractDreamMemories({ turnCount, transcript }, { enabled: true, turnThreshold: 24, transcriptWindow: 4 });
+    }
+    try {
+        const recent = transcript.slice(-6);
+        const combined = recent.join("\n---\n");
+        const resp = await axios.post(config.endpoint + "/chat/completions", {
+            model: config.model,
+            messages: [
+                { role: "system", content: DREAM_PROMPT },
+                { role: "user", content: combined.slice(0, 4000) },
+            ],
+            max_tokens: config.maxTokens,
+            temperature: 0.3,
+        }, {
+            headers: {
+                Authorization: "Bearer " + config.apiKey,
+                "Content-Type": "application/json",
+            },
+            timeout: 30_000,
+        });
+        const content = resp.data.choices?.[0]?.message?.content?.trim() ?? "";
+        // parse JSON array from response
+        const jsonMatch = content.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((item) => String(item).trim())
+                    .filter((s) => s.length > 0 && s.length <= 200);
+            }
+        }
+        // fallback to regex
+        return extractDreamMemories({ turnCount, transcript }, { enabled: true, turnThreshold: 24, transcriptWindow: 4 });
+    }
+    catch {
+        // fallback to regex on any error
+        return extractDreamMemories({ turnCount, transcript }, { enabled: true, turnThreshold: 24, transcriptWindow: 4 });
+    }
+}

package/dist/memory/projection-worker.d.ts

@@ -0,0 +1,30 @@
+import { WriteAheadLog, WALEntry } from "./wal.js";
+import type { PersistedEntry } from "../types.js";
+export interface ProjectionWorkerOptions {
+    intervalMs: number;
+    maxPendingEntries: number;
+}
+export declare class ProjectionWorker {
+    private wal;
+    private timer;
+    private running;
+    private applyEntry;
+    private getEntries;
+    private onCheckpoint?;
+    private options;
+    private firstRun;
+    private projectedCount;
+    constructor(wal: WriteAheadLog, callbacks: {
+        applyEntry: (entry: WALEntry) => void;
+        getEntries: () => PersistedEntry[];
+        onCheckpoint?: (entries: PersistedEntry[]) => Promise<void>;
+    }, options?: Partial<ProjectionWorkerOptions>);
+    start(): void;
+    stop(): void;
+    projectOnce(): Promise<number>;
+    forceCheckpoint(): Promise<void>;
+    isRunning(): boolean;
+    getProjectedCount(): number;
+    private tick;
+}
+//# sourceMappingURL=projection-worker.d.ts.map

package/dist/memory/projection-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-worker.d.ts","sourceRoot":"","sources":["../../src/memory/projection-worker.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAOD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,YAAY,CAAC,CAA+C;IACpE,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,cAAc,CAAK;gBAGzB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE;QACT,UAAU,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;QACtC,UAAU,EAAE,MAAM,cAAc,EAAE,CAAC;QACnC,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KAC7D,EACD,OAAO,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAShD,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI;IAQN,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IA4B9B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtC,SAAS,IAAI,OAAO;IAIpB,iBAAiB,IAAI,MAAM;YAMb,IAAI;CAenB"}