feique 1.1.0

package/dist/state/memory-store.js

@@ -0,0 +1,713 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import { ensureDir } from '../utils/fs.js';
+import { SerialExecutor } from '../utils/serial-executor.js';
+import { LocalEmbeddingProvider, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from '../memory/embeddings.js';
+const MEMORY_SCHEMA_VERSION = 5;
+export class MemoryStore {
+    dbPath;
+    serial = new SerialExecutor();
+    embedder;
+    _db = null;
+    _schemaReady = false;
+    _lastTs = 0;
+    constructor(stateDir, embedder) {
+        this.dbPath = path.join(stateDir, 'memory.db');
+        this.embedder = embedder ?? new LocalEmbeddingProvider();
+    }
+    /** Return an ISO timestamp that is strictly greater than any previous call. */
+    monotonicNow() {
+        const now = Date.now();
+        this._lastTs = now > this._lastTs ? now : this._lastTs + 1;
+        return new Date(this._lastTs).toISOString();
+    }
+    async upsertThreadSummary(record) {
+        return this.serial.run(async () => {
+            const now = this.monotonicNow();
+            return this.withDb((db) => {
+                db.prepare(`
+          INSERT INTO thread_summaries (
+            conversation_key, project_alias, thread_id, summary, recent_prompt, recent_response_excerpt,
+            files_touched_json, open_tasks_json, decisions_json, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(conversation_key, project_alias, thread_id) DO UPDATE SET
+            summary = excluded.summary,
+            recent_prompt = excluded.recent_prompt,
+            recent_response_excerpt = excluded.recent_response_excerpt,
+            files_touched_json = excluded.files_touched_json,
+            open_tasks_json = excluded.open_tasks_json,
+            decisions_json = excluded.decisions_json,
+            updated_at = excluded.updated_at
+        `).run(record.conversation_key, record.project_alias, record.thread_id, record.summary, record.recent_prompt ?? null, record.recent_response_excerpt ?? null, JSON.stringify(record.files_touched), JSON.stringify(record.open_tasks), JSON.stringify(record.decisions), now, now);
+                const row = db.prepare(`
+          SELECT conversation_key, project_alias, thread_id, summary, recent_prompt, recent_response_excerpt,
+                 files_touched_json, open_tasks_json, decisions_json, created_at, updated_at
+          FROM thread_summaries
+          WHERE conversation_key = ? AND project_alias = ? AND thread_id = ?
+        `).get(record.conversation_key, record.project_alias, record.thread_id);
+                return mapThreadSummaryRow(row);
+            });
+        });
+    }
+    async getThreadSummary(conversationKey, projectAlias, threadId) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const row = db.prepare(`
+        SELECT conversation_key, project_alias, thread_id, summary, recent_prompt, recent_response_excerpt,
+               files_touched_json, open_tasks_json, decisions_json, created_at, updated_at
+        FROM thread_summaries
+        WHERE conversation_key = ? AND project_alias = ? AND thread_id = ?
+      `).get(conversationKey, projectAlias, threadId);
+            return row ? mapThreadSummaryRow(row) : null;
+        });
+    }
+    async saveMemory(input) {
+        return this.serial.run(async () => {
+            const now = this.monotonicNow();
+            const record = {
+                id: randomUUID(),
+                scope: input.scope,
+                project_alias: input.project_alias,
+                chat_id: input.scope === 'group' ? input.chat_id : undefined,
+                title: input.title,
+                content: input.content,
+                tags: input.tags ?? [],
+                source: input.source ?? 'manual',
+                pinned: input.pinned ?? false,
+                confidence: input.confidence ?? 1,
+                created_by: input.created_by,
+                created_at: now,
+                updated_at: now,
+                last_accessed_at: now,
+                expires_at: input.expires_at,
+            };
+            const embeddingText = `${record.title} ${record.content} ${record.tags.join(' ')}`;
+            const embeddingJson = serializeEmbedding(await this.embedder.embed(embeddingText));
+            return this.withDb((db) => {
+                db.prepare(`
+          INSERT INTO project_memories (
+            id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at, embedding_json
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(record.id, record.scope, record.project_alias, record.chat_id ?? null, record.title, record.content, JSON.stringify(record.tags), record.source, record.pinned ? 1 : 0, record.confidence, record.created_by ?? null, record.created_at, record.updated_at, record.last_accessed_at ?? null, record.expires_at ?? null, embeddingJson);
+                return record;
+            });
+        });
+    }
+    async saveProjectMemory(input) {
+        return this.saveMemory({ ...input, scope: 'project' });
+    }
+    async saveGroupMemory(input) {
+        return this.saveMemory({ ...input, scope: 'group' });
+    }
+    async searchMemories(selector, query, limit, filters) {
+        await this.serial.wait();
+        const touchedAt = this.monotonicNow();
+        const queryEmbedding = await this.embedder.embed(query);
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector, filters);
+            // Phase 1: FTS5 keyword search (works for both Chinese and English)
+            const ftsQuery = buildFtsQuery(query);
+            let ftsRows = [];
+            if (ftsQuery) {
+                const { whereClause: joinWhere, params: joinParams } = buildMemorySelectorWhere(selector, filters, undefined, 'pm');
+                ftsRows = db.prepare(`
+          SELECT pm.id, pm.scope, pm.project_alias, pm.chat_id, pm.title, pm.content, pm.tags_json, pm.source, pm.pinned, pm.confidence, pm.created_by, pm.created_at, pm.updated_at, pm.last_accessed_at, pm.expires_at, pm.embedding_json
+          FROM memory_fts
+          JOIN project_memories pm ON pm.rowid = memory_fts.rowid
+          WHERE ${joinWhere}
+            AND memory_fts MATCH ?
+          ORDER BY pm.pinned DESC, bm25(memory_fts), pm.updated_at DESC
+          LIMIT ?
+        `).all(...joinParams, ftsQuery, limit * 2);
+            }
+            // Phase 2: Vector similarity search (semantic matching)
+            const allRows = db.prepare(`
+        SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at, embedding_json
+        FROM project_memories
+        WHERE ${whereClause}
+          AND embedding_json IS NOT NULL
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `).all(...params, 200);
+            const vectorScored = [];
+            for (const row of allRows) {
+                const embJson = row.embedding_json;
+                if (!embJson)
+                    continue;
+                const embedding = deserializeEmbedding(embJson);
+                if (!embedding)
+                    continue;
+                const score = cosineSimilarity(queryEmbedding, embedding);
+                if (score > 0.35) {
+                    vectorScored.push({ row, score });
+                }
+            }
+            vectorScored.sort((a, b) => b.score - a.score);
+            // Phase 3: Merge and deduplicate
+            const seen = new Set();
+            const merged = [];
+            // FTS results first (keyword relevance)
+            for (const row of ftsRows) {
+                if (!seen.has(row.id)) {
+                    seen.add(row.id);
+                    merged.push(row);
+                }
+            }
+            // Then vector results (semantic relevance)
+            for (const { row } of vectorScored) {
+                if (!seen.has(row.id)) {
+                    seen.add(row.id);
+                    merged.push(row);
+                }
+            }
+            // Fallback: LIKE search if both FTS and vector returned nothing
+            if (merged.length === 0) {
+                const normalized = `%${query.trim().toLowerCase()}%`;
+                const fallbackRows = db.prepare(`
+          SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at, embedding_json
+          FROM project_memories
+          WHERE ${whereClause}
+            AND (
+              lower(title) LIKE ?
+              OR lower(content) LIKE ?
+              OR lower(tags_json) LIKE ?
+            )
+          ORDER BY pinned DESC, updated_at DESC
+          LIMIT ?
+        `).all(...params, normalized, normalized, normalized, limit);
+                return touchRowsAndMap(db, fallbackRows, touchedAt);
+            }
+            // Pinned first, then limit
+            merged.sort((a, b) => (b.pinned ?? 0) - (a.pinned ?? 0));
+            const records = touchRowsAndMap(db, merged.slice(0, limit), touchedAt);
+            // Post-filter on mapped records: ensure expired/archived records don't leak
+            const now = new Date().toISOString();
+            return records.filter((r) => !r.archived_at && (!r.expires_at || r.expires_at > now));
+        });
+    }
+    async searchProjectMemories(projectAlias, query, limit, filters) {
+        return this.searchMemories({ scope: 'project', project_alias: projectAlias }, query, limit, filters);
+    }
+    async searchGroupMemories(projectAlias, chatId, query, limit, filters) {
+        return this.searchMemories({ scope: 'group', project_alias: projectAlias, chat_id: chatId }, query, limit, filters);
+    }
+    async getMemory(selector, id) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector);
+            const row = db.prepare(`
+        SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, archived_at, archived_by, archive_reason, expires_at
+        FROM project_memories
+        WHERE id = ?
+          AND ${whereClause}
+      `).get(id, ...params);
+            return row ? mapMemoryRow(row) : null;
+        });
+    }
+    async getMemoryById(selector, id, options) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector, undefined, options);
+            const row = db.prepare(`
+        SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, archived_at, archived_by, archive_reason, expires_at
+        FROM project_memories
+        WHERE id = ?
+          AND ${whereClause}
+      `).get(id, ...params);
+            return row ? mapMemoryRow(row) : null;
+        });
+    }
+    async listRecentMemories(selector, limit, filters) {
+        await this.serial.wait();
+        const touchedAt = this.monotonicNow();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector, filters);
+            const rows = db.prepare(`
+        SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at
+        FROM project_memories
+        WHERE ${whereClause}
+        ORDER BY pinned DESC, updated_at DESC
+        LIMIT ?
+      `).all(...params, limit);
+            return touchRowsAndMap(db, rows, touchedAt);
+        });
+    }
+    async listRecentProjectMemories(projectAlias, limit, filters) {
+        return this.listRecentMemories({ scope: 'project', project_alias: projectAlias }, limit, filters);
+    }
+    async listRecentGroupMemories(projectAlias, chatId, limit, filters) {
+        return this.listRecentMemories({ scope: 'group', project_alias: projectAlias, chat_id: chatId }, limit, filters);
+    }
+    async countMemories(selector) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector);
+            const row = db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM project_memories
+        WHERE ${whereClause}
+      `).get(...params);
+            return Number(row.count ?? 0);
+        });
+    }
+    async countProjectMemories(projectAlias) {
+        return this.countMemories({ scope: 'project', project_alias: projectAlias });
+    }
+    async countGroupMemories(projectAlias, chatId) {
+        return this.countMemories({ scope: 'group', project_alias: projectAlias, chat_id: chatId });
+    }
+    async countPinnedMemories(selector) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector);
+            const row = db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM project_memories
+        WHERE ${whereClause}
+          AND pinned = 1
+      `).get(...params);
+            return Number(row.count ?? 0);
+        });
+    }
+    async countPinnedProjectMemories(projectAlias) {
+        return this.countPinnedMemories({ scope: 'project', project_alias: projectAlias });
+    }
+    async countPinnedGroupMemories(projectAlias, chatId) {
+        return this.countPinnedMemories({ scope: 'group', project_alias: projectAlias, chat_id: chatId });
+    }
+    async getMemoryStats(selector) {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const now = this.monotonicNow();
+            const params = [selector.scope, selector.project_alias];
+            const baseClauses = ['scope = ?', 'project_alias = ?'];
+            if (selector.scope === 'group') {
+                baseClauses.push('chat_id = ?');
+                params.push(selector.chat_id ?? null);
+            }
+            const baseWhere = baseClauses.join(' AND ');
+            const row = db.prepare(`
+        SELECT
+          SUM(CASE WHEN archived_at IS NULL AND (expires_at IS NULL OR expires_at > ?) THEN 1 ELSE 0 END) AS active_count,
+          SUM(CASE WHEN archived_at IS NOT NULL THEN 1 ELSE 0 END) AS archived_count,
+          SUM(CASE WHEN archived_at IS NULL AND expires_at IS NOT NULL AND expires_at <= ? THEN 1 ELSE 0 END) AS expired_count,
+          SUM(CASE WHEN archived_at IS NULL AND pinned = 1 AND (expires_at IS NULL OR expires_at > ?) THEN 1 ELSE 0 END) AS pinned_count,
+          MAX(updated_at) AS latest_updated_at,
+          MAX(last_accessed_at) AS latest_accessed_at,
+          MAX(archived_at) AS latest_archived_at
+        FROM project_memories
+        WHERE ${baseWhere}
+      `).get(now, now, now, ...params);
+            return {
+                active_count: Number(row.active_count ?? 0),
+                archived_count: Number(row.archived_count ?? 0),
+                expired_count: Number(row.expired_count ?? 0),
+                pinned_count: Number(row.pinned_count ?? 0),
+                latest_updated_at: row.latest_updated_at ?? undefined,
+                latest_accessed_at: row.latest_accessed_at ?? undefined,
+                latest_archived_at: row.latest_archived_at ?? undefined,
+            };
+        });
+    }
+    async cleanupExpiredMemories(selector) {
+        return this.serial.run(async () => {
+            return this.withDb((db) => {
+                const now = this.monotonicNow();
+                const clauses = ['archived_at IS NULL', 'expires_at IS NOT NULL', 'expires_at <= ?'];
+                const params = [now];
+                if (selector) {
+                    clauses.push('scope = ?');
+                    params.push(selector.scope);
+                    clauses.push('project_alias = ?');
+                    params.push(selector.project_alias);
+                    if (selector.scope === 'group') {
+                        clauses.push('chat_id = ?');
+                        params.push(selector.chat_id ?? null);
+                    }
+                }
+                const result = db.prepare(`
+          UPDATE project_memories
+          SET archived_at = ?, archived_by = ?, archive_reason = ?, pinned = 0, updated_at = ?
+          WHERE ${clauses.join(' AND ')}
+        `).run(now, 'system', 'expired', now, ...params);
+                return Number(result.changes ?? 0);
+            });
+        });
+    }
+    async getOldestPinnedMemory(selector, basis = 'updated_at') {
+        await this.serial.wait();
+        return this.withDb((db) => {
+            const { whereClause, params } = buildMemorySelectorWhere(selector, {});
+            const orderBy = basis === 'last_accessed_at'
+                ? 'COALESCE(last_accessed_at, updated_at, created_at) ASC, updated_at ASC, rowid ASC'
+                : 'updated_at ASC, created_at ASC, rowid ASC';
+            const row = db.prepare(`
+        SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at
+        FROM project_memories
+        WHERE ${whereClause}
+          AND pinned = 1
+        ORDER BY ${orderBy}
+        LIMIT 1
+      `).get(...params);
+            return row ? mapMemoryRow(row) : null;
+        });
+    }
+    async setMemoryPinned(selector, id, pinned) {
+        return this.serial.run(async () => {
+            const now = this.monotonicNow();
+            return this.withDb((db) => {
+                const { whereClause, params } = buildMemorySelectorWhere(selector);
+                const result = db.prepare(`
+          UPDATE project_memories
+          SET pinned = ?, updated_at = ?, last_accessed_at = ?
+          WHERE id = ?
+            AND ${whereClause}
+        `).run(pinned ? 1 : 0, now, now, id, ...params);
+                if (result.changes === 0) {
+                    return null;
+                }
+                const row = db.prepare(`
+          SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, expires_at
+          FROM project_memories
+          WHERE id = ?
+            AND ${whereClause}
+        `).get(id, ...params);
+                return row ? mapMemoryRow(row) : null;
+            });
+        });
+    }
+    async archiveMemory(selector, id, input) {
+        return this.serial.run(async () => {
+            const now = this.monotonicNow();
+            return this.withDb((db) => {
+                const { whereClause, params } = buildMemorySelectorWhere(selector);
+                const result = db.prepare(`
+          UPDATE project_memories
+          SET archived_at = ?, archived_by = ?, archive_reason = ?, pinned = 0, updated_at = ?
+          WHERE id = ?
+            AND ${whereClause}
+        `).run(now, input?.archived_by ?? null, input?.reason ?? 'manual', now, id, ...params);
+                if (result.changes === 0) {
+                    return null;
+                }
+                const row = db.prepare(`
+          SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, archived_at, archived_by, archive_reason, expires_at
+          FROM project_memories
+          WHERE id = ?
+            AND scope = ?
+            AND project_alias = ?
+            ${selector.scope === 'group' ? 'AND chat_id = ?' : ''}
+        `).get(id, selector.scope, selector.project_alias, ...(selector.scope === 'group' ? [selector.chat_id ?? null] : []));
+                return row ? mapMemoryRow(row) : null;
+            });
+        });
+    }
+    async restoreMemory(selector, id, restoredBy) {
+        return this.serial.run(async () => {
+            const now = this.monotonicNow();
+            return this.withDb((db) => {
+                const { whereClause, params } = buildMemorySelectorWhere(selector, undefined, { includeArchived: true, includeExpired: true });
+                const result = db.prepare(`
+          UPDATE project_memories
+          SET archived_at = NULL,
+              archived_by = NULL,
+              archive_reason = NULL,
+              updated_at = ?,
+              last_accessed_at = ?,
+              expires_at = CASE
+                WHEN expires_at IS NOT NULL AND expires_at <= ? THEN NULL
+                ELSE expires_at
+              END
+          WHERE id = ?
+            AND archived_at IS NOT NULL
+            AND ${whereClause}
+        `).run(now, now, now, id, ...params);
+                if (result.changes === 0) {
+                    return null;
+                }
+                const restored = db.prepare(`
+          SELECT id, scope, project_alias, chat_id, title, content, tags_json, source, pinned, confidence, created_by, created_at, updated_at, last_accessed_at, archived_at, archived_by, archive_reason, expires_at
+          FROM project_memories
+          WHERE id = ?
+            AND ${whereClause}
+        `).get(id, ...params);
+                if (restoredBy) {
+                    void restoredBy;
+                }
+                return restored ? mapMemoryRow(restored) : null;
+            });
+        });
+    }
+    async ensureReady() {
+        await this.serial.run(async () => {
+            await ensureDir(path.dirname(this.dbPath));
+            this.getDb();
+        });
+    }
+    close() {
+        if (this._db) {
+            this._db.close();
+            this._db = null;
+            this._schemaReady = false;
+        }
+    }
+    getDb() {
+        if (!this._db) {
+            fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+            this._db = new DatabaseSync(this.dbPath);
+        }
+        if (!this._schemaReady) {
+            initializeSchema(this._db);
+            this._schemaReady = true;
+        }
+        return this._db;
+    }
+    withDb(callback) {
+        return callback(this.getDb());
+    }
+}
+function initializeSchema(db) {
+    db.exec('PRAGMA journal_mode = WAL;');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS thread_summaries (
+      conversation_key TEXT NOT NULL,
+      project_alias TEXT NOT NULL,
+      thread_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      recent_prompt TEXT,
+      recent_response_excerpt TEXT,
+      files_touched_json TEXT NOT NULL DEFAULT '[]',
+      open_tasks_json TEXT NOT NULL DEFAULT '[]',
+      decisions_json TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (conversation_key, project_alias, thread_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS project_memories (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL DEFAULT 'project',
+      project_alias TEXT NOT NULL,
+      chat_id TEXT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tags_json TEXT NOT NULL DEFAULT '[]',
+      source TEXT NOT NULL DEFAULT 'manual',
+      pinned INTEGER NOT NULL DEFAULT 0,
+      confidence REAL NOT NULL DEFAULT 1,
+      created_by TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_accessed_at TEXT,
+      archived_at TEXT,
+      archived_by TEXT,
+      archive_reason TEXT,
+      expires_at TEXT
+    );
+  `);
+    const userVersion = getUserVersion(db);
+    if (userVersion < MEMORY_SCHEMA_VERSION) {
+        migrateProjectMemoriesSchema(db);
+        db.exec(`
+      DROP TRIGGER IF EXISTS project_memories_ai;
+      DROP TRIGGER IF EXISTS project_memories_ad;
+      DROP TRIGGER IF EXISTS project_memories_au;
+      DROP TABLE IF EXISTS memory_fts;
+    `);
+    }
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_project_memories_scope_project_updated
+      ON project_memories(scope, project_alias, updated_at DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_project_memories_scope_project_chat_updated
+      ON project_memories(scope, project_alias, chat_id, updated_at DESC);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      title,
+      content,
+      tags_json,
+      content='project_memories',
+      content_rowid='rowid',
+      tokenize='unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS project_memories_ai AFTER INSERT ON project_memories BEGIN
+      INSERT INTO memory_fts(rowid, title, content, tags_json)
+      VALUES (new.rowid, new.title, new.content, new.tags_json);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS project_memories_ad AFTER DELETE ON project_memories BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, title, content, tags_json)
+      VALUES ('delete', old.rowid, old.title, old.content, old.tags_json);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS project_memories_au AFTER UPDATE ON project_memories BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, title, content, tags_json)
+      VALUES ('delete', old.rowid, old.title, old.content, old.tags_json);
+      INSERT INTO memory_fts(rowid, title, content, tags_json)
+      VALUES (new.rowid, new.title, new.content, new.tags_json);
+    END;
+  `);
+    if (userVersion < MEMORY_SCHEMA_VERSION) {
+        db.prepare("INSERT INTO memory_fts(memory_fts) VALUES ('rebuild')").run();
+        db.exec(`PRAGMA user_version = ${MEMORY_SCHEMA_VERSION};`);
+    }
+}
+function migrateProjectMemoriesSchema(db) {
+    const columns = db.prepare('PRAGMA table_info(project_memories)').all();
+    const names = new Set(columns.map((column) => column.name));
+    if (!names.has('scope')) {
+        db.exec("ALTER TABLE project_memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'");
+    }
+    if (!names.has('chat_id')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN chat_id TEXT');
+    }
+    if (!names.has('last_accessed_at')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN last_accessed_at TEXT');
+        db.exec('UPDATE project_memories SET last_accessed_at = updated_at WHERE last_accessed_at IS NULL');
+    }
+    if (!names.has('archived_at')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN archived_at TEXT');
+    }
+    if (!names.has('archived_by')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN archived_by TEXT');
+    }
+    if (!names.has('archive_reason')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN archive_reason TEXT');
+    }
+    if (!names.has('embedding_json')) {
+        db.exec('ALTER TABLE project_memories ADD COLUMN embedding_json TEXT');
+    }
+}
+function getUserVersion(db) {
+    const row = db.prepare('PRAGMA user_version').get();
+    return Number(row?.user_version ?? 0);
+}
+function buildMemorySelectorWhere(selector, filters, options, tablePrefix) {
+    const p = tablePrefix ? `${tablePrefix}.` : '';
+    const params = [selector.scope, selector.project_alias];
+    const clauses = [
+        `${p}scope = ?`,
+        `${p}project_alias = ?`,
+    ];
+    if (!options?.includeExpired) {
+        clauses.push(`(${p}expires_at IS NULL OR ${p}expires_at > ?)`);
+        params.push(new Date().toISOString());
+    }
+    if (!options?.includeArchived) {
+        clauses.push(`${p}archived_at IS NULL`);
+    }
+    if (selector.scope === 'group') {
+        clauses.push(`${p}chat_id = ?`);
+        params.push(selector.chat_id ?? null);
+    }
+    if (filters?.source) {
+        clauses.push(`${p}source = ?`);
+        params.push(filters.source);
+    }
+    if (filters?.created_by) {
+        clauses.push(`${p}created_by = ?`);
+        params.push(filters.created_by);
+    }
+    if (filters?.tag) {
+        clauses.push(`lower(${p}tags_json) LIKE ?`);
+        params.push(`%${filters.tag.toLowerCase()}%`);
+    }
+    return {
+        whereClause: clauses.join(' AND '),
+        params,
+    };
+}
+/**
+ * Build FTS5 query supporting both English and Chinese text.
+ * English: word prefix matching (e.g., "auth*")
+ * Chinese: character-level matching (FTS5 unicode61 tokenizes CJK per-character)
+ */
+function buildFtsQuery(input) {
+    const terms = [];
+    // Extract English/numeric tokens → prefix match
+    const englishTokens = input.toLowerCase().match(/[a-z][a-z0-9_-]*/g);
+    if (englishTokens) {
+        for (const token of englishTokens) {
+            if (token.length > 1) {
+                terms.push(`${token}*`);
+            }
+        }
+    }
+    // Extract CJK characters → exact character match
+    // FTS5 with unicode61 tokenizes CJK text per-character, so each character is a token
+    const cjkChars = input.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g);
+    if (cjkChars) {
+        for (const char of cjkChars) {
+            terms.push(char);
+        }
+    }
+    if (terms.length === 0) {
+        return null;
+    }
+    // Use OR for mixed queries (find docs matching any term)
+    // then rely on BM25 scoring to rank by relevance
+    return terms.join(' OR ');
+}
+function mapThreadSummaryRow(row) {
+    return {
+        conversation_key: row.conversation_key,
+        project_alias: row.project_alias,
+        thread_id: row.thread_id,
+        summary: row.summary,
+        recent_prompt: row.recent_prompt ?? undefined,
+        recent_response_excerpt: row.recent_response_excerpt ?? undefined,
+        files_touched: parseJsonArray(row.files_touched_json),
+        open_tasks: parseJsonArray(row.open_tasks_json),
+        decisions: parseJsonArray(row.decisions_json),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function mapMemoryRow(row) {
+    return {
+        id: row.id,
+        scope: row.scope === 'group' ? 'group' : 'project',
+        project_alias: row.project_alias,
+        chat_id: row.chat_id ?? undefined,
+        title: row.title,
+        content: row.content,
+        tags: parseJsonArray(row.tags_json),
+        source: row.source,
+        pinned: row.pinned === 1,
+        confidence: row.confidence,
+        created_by: row.created_by ?? undefined,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        last_accessed_at: row.last_accessed_at ?? undefined,
+        archived_at: row.archived_at ?? undefined,
+        archived_by: row.archived_by ?? undefined,
+        archive_reason: row.archive_reason ?? undefined,
+        expires_at: row.expires_at ?? undefined,
+    };
+}
+function touchRowsAndMap(db, rows, touchedAt) {
+    if (rows.length === 0) {
+        return [];
+    }
+    const ids = rows.map((row) => row.id);
+    const placeholders = ids.map(() => '?').join(', ');
+    db.prepare(`
+    UPDATE project_memories
+    SET last_accessed_at = ?
+    WHERE id IN (${placeholders})
+  `).run(touchedAt, ...ids);
+    return rows.map((row) => mapMemoryRow({ ...row, last_accessed_at: touchedAt }));
+}
+function parseJsonArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=memory-store.js.map