@agent-spaces/server 0.3.62 → 0.3.64

package/dist/services/skill.js

@@ -1,5 +1,8 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
 import { listTemplates } from './agent.js';
 const SKILL_FILE = 'SKILL.md';
@@ -12,17 +15,16 @@ function getSkillMetaPath() {
 function readMeta() {
     const path = getSkillMetaPath();
     if (!existsSync(path))
-        return { favorites: [], groups: {}, disabled: [] };
+        return { favorites: [], groups: {} };
     try {
         const raw = JSON.parse(readFileSync(path, 'utf-8'));
         return {
             favorites: raw.favorites || [],
             groups: raw.groups || {},
-            disabled: raw.disabled || [],
         };
     }
     catch {
-        return { favorites: [], groups: {}, disabled: [] };
+        return { favorites: [], groups: {} };
     }
 }
 function writeMeta(meta) {
@@ -84,7 +86,6 @@ export function listSkills() {
             filename: `${folderName}/${SKILL_FILE}`,
             content,
             favorited: meta.favorites.includes(folderName),
-            enabled: !meta.disabled.includes(folderName),
             group: meta.groups[folderName] || '',
             boundAgents,
         };
@@ -133,7 +134,6 @@ export function importSkill(filename, content, group) {
         filename: `${folderName}/${SKILL_FILE}`,
         content,
         favorited: false,
-        enabled: true,
         group: group || '',
         boundAgents: [],
     };
@@ -153,7 +153,6 @@ export function importSkillsBatch(items) {
             filename: `${folderName}/${SKILL_FILE}`,
             content: item.content,
             favorited: false,
-            enabled: true,
             group: item.group || '',
             boundAgents: [],
         });
@@ -161,6 +160,50 @@ export function importSkillsBatch(items) {
     writeMeta(meta);
     return results;
 }
+export function importSkillFromStore(storePath, group) {
+    // storePath is like "group-name/skill-name", relative to public/skills/
+    const publicSkillsDir = join(getDataDir(), '..', 'public', 'skills');
+    // Try relative to package first
+    let srcDir = null;
+    const candidates = [
+        join(process.cwd(), 'public', 'skills', storePath),
+        join(import.meta.dirname ?? '', '..', 'public', 'skills', storePath),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c) && statSync(c).isDirectory()) {
+            srcDir = c;
+            break;
+        }
+    }
+    if (!srcDir)
+        return null;
+    const skillName = basename(storePath);
+    const skillsDir = getSkillsDir();
+    const destDir = join(skillsDir, skillName);
+    // Copy entire folder
+    if (existsSync(destDir))
+        rmSync(destDir, { recursive: true, force: true });
+    cpSync(srcDir, destDir, { recursive: true, force: true });
+    // Set group in meta
+    if (group) {
+        const meta = readMeta();
+        meta.groups[skillName] = group;
+        writeMeta(meta);
+    }
+    // Read content for return
+    const skillFile = join(destDir, SKILL_FILE);
+    const content = existsSync(skillFile) ? readFileSync(skillFile, 'utf-8') : '';
+    const fm = parseFrontmatter(content);
+    return {
+        name: skillName,
+        description: fm.description || '',
+        filename: `${skillName}/${SKILL_FILE}`,
+        content,
+        favorited: false,
+        group,
+        boundAgents: [],
+    };
+}
 export function toggleFavorite(name) {
     const meta = readMeta();
     const idx = meta.favorites.indexOf(name);
@@ -173,31 +216,6 @@ export function toggleFavorite(name) {
     writeMeta(meta);
     return idx < 0;
 }
-export function toggleEnabled(name) {
-    const meta = readMeta();
-    const idx = meta.disabled.indexOf(name);
-    if (idx >= 0) {
-        meta.disabled.splice(idx, 1);
-    }
-    else {
-        meta.disabled.push(name);
-    }
-    writeMeta(meta);
-    return idx >= 0; // true = now enabled
-}
-export function toggleAllEnabled(names, enabled) {
-    const meta = readMeta();
-    if (enabled) {
-        meta.disabled = meta.disabled.filter((n) => !names.includes(n));
-    }
-    else {
-        const set = new Set(meta.disabled);
-        for (const n of names)
-            set.add(n);
-        meta.disabled = [...set];
-    }
-    writeMeta(meta);
-}
 export function updateSkillContent(name, content) {
     const skillsDir = getSkillsDir();
     const filePath = join(skillsDir, name, SKILL_FILE);
@@ -216,7 +234,6 @@ export function deleteSkill(name) {
     const meta = readMeta();
     meta.favorites = meta.favorites.filter((n) => n !== name);
     delete meta.groups[name];
-    meta.disabled = meta.disabled.filter((n) => n !== name);
     writeMeta(meta);
     return true;
 }
@@ -238,7 +255,10 @@ export function checkSkillSync() {
             const agentFile = join(agentSkillsDir, `${skillName}.md`);
             if (!existsSync(globalFolder) || !statSync(globalFolder).isDirectory())
                 continue;
-            const globalStat = statSync(globalFolder);
+            // Use SKILL.md file mtime — directory mtime is unreliable on Windows
+            if (!existsSync(globalSkillFile))
+                continue;
+            const globalStat = statSync(globalSkillFile);
             const agentExists = existsSync(agentFolder) || existsSync(agentFile);
             if (!agentExists) {
                 // Agent skill missing — needs sync
@@ -251,8 +271,13 @@ export function checkSkillSync() {
                 });
                 continue;
             }
-            const agentPath = existsSync(agentFolder) ? agentFolder : agentFile;
-            const agentStat = statSync(agentPath);
+            // Find the actual agent SKILL.md path
+            const agentSkillFile = existsSync(agentFolder)
+                ? join(agentFolder, SKILL_FILE)
+                : agentFile;
+            if (!existsSync(agentSkillFile))
+                continue;
+            const agentStat = statSync(agentSkillFile);
             if (globalStat.mtimeMs > agentStat.mtimeMs) {
                 result.push({
                     agentId: agent.id,
@@ -290,4 +315,92 @@ export function syncSkills(items) {
     }
     return synced;
 }
+export function listSkillFiles(name) {
+    const skillsDir = getSkillsDir();
+    const folderPath = join(skillsDir, name);
+    if (!existsSync(folderPath) || !statSync(folderPath).isDirectory())
+        return [];
+    function walk(dir, prefix) {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const result = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith('_') || entry.name === '.DS_Store')
+                continue;
+            const fullPath = join(dir, entry.name);
+            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                result.push({ name: entry.name, path: relativePath, isDirectory: true });
+                result.push(...walk(fullPath, relativePath));
+            }
+            else {
+                result.push({ name: entry.name, path: relativePath, isDirectory: false });
+            }
+        }
+        return result;
+    }
+    return walk(folderPath, '');
+}
+export function readSkillFile(name, filePath) {
+    const skillsDir = getSkillsDir();
+    const fullPath = join(skillsDir, name, filePath);
+    // Prevent path traversal
+    if (!fullPath.startsWith(join(skillsDir, name)))
+        return null;
+    if (!existsSync(fullPath) || !statSync(fullPath).isFile())
+        return null;
+    return readFileSync(fullPath, 'utf-8');
+}
+export function writeSkillFile(name, filePath, content) {
+    const skillsDir = getSkillsDir();
+    const fullPath = join(skillsDir, name, filePath);
+    // Prevent path traversal
+    if (!fullPath.startsWith(join(skillsDir, name)))
+        return false;
+    const dir = join(fullPath, '..');
+    ensureDir(dir);
+    writeFileSync(fullPath, content, 'utf-8');
+    return true;
+}
+export function importSkillsFromGit(gitUrl) {
+    const cloneDir = join(tmpdir(), `agent-spaces-git-${randomUUID()}`);
+    try {
+        execFileSync('git', ['clone', '--depth', '1', gitUrl, cloneDir], {
+            timeout: 60_000,
+            stdio: 'pipe',
+        });
+        const results = [];
+        function walk(dir) {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (entry.name === SKILL_FILE || entry.name.endsWith('.md')) {
+                    const folderName = basename(dir);
+                    if (folderName === basename(cloneDir))
+                        continue; // skip repo root
+                    const existing = results.find((r) => r.name === folderName);
+                    // Prefer SKILL.md over generic .md
+                    if (!existing || (entry.name === SKILL_FILE && existing.content)) {
+                        const content = readFileSync(full, 'utf-8');
+                        if (!existing) {
+                            results.push({ name: folderName, content });
+                        }
+                        else {
+                            existing.content = content;
+                        }
+                    }
+                }
+            }
+        }
+        walk(cloneDir);
+        return results;
+    }
+    finally {
+        rmSync(cloneDir, { recursive: true, force: true });
+    }
+}
 //# sourceMappingURL=skill.js.map

package/dist/storage/database-store.js

@@ -0,0 +1,365 @@
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { createHash } from 'node:crypto';
+import { v4 as uuid } from 'uuid';
+import { getDataDir, ensureDir } from './json-store.js';
+let db = null;
+function openDb() {
+    if (db)
+        return db;
+    const dir = join(getDataDir(), 'database');
+    ensureDir(dir);
+    db = new DatabaseSync(join(dir, 'database.sqlite'));
+    const hasDocNodes = Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'doc_nodes'").get());
+    const hasDatabaseId = hasDocNodes
+        && db.prepare('PRAGMA table_info(doc_nodes)').all()
+            .some((column) => column.name === 'database_id');
+    if (hasDocNodes && !hasDatabaseId) {
+        db.exec('DROP TABLE IF EXISTS doc_nodes; DROP TABLE IF EXISTS databases;');
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS databases (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      name TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      embedding_model_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS doc_nodes (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      icon TEXT NOT NULL DEFAULT '',
+      cover TEXT NOT NULL DEFAULT '',
+      content TEXT NOT NULL DEFAULT '',
+      parent_id TEXT,
+      is_trash INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS database_embeddings (
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      path TEXT NOT NULL DEFAULT '',
+      content TEXT NOT NULL DEFAULT '',
+      content_hash TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      model_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (workspace_id, database_id, node_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS doc_node_versions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      patch_json TEXT NOT NULL,
+      old_hash TEXT NOT NULL,
+      new_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_databases_workspace ON databases(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_workspace ON doc_nodes(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_database ON doc_nodes(workspace_id, database_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_parent ON doc_nodes(workspace_id, database_id, parent_id);
+    CREATE INDEX IF NOT EXISTS idx_database_embeddings_database ON database_embeddings(workspace_id, database_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_node_versions_node ON doc_node_versions(workspace_id, database_id, node_id, created_at DESC);
+  `);
+    ensureColumn('databases', 'embedding_model_id', 'TEXT');
+    migrateEmbeddingModelColumn();
+    return db;
+}
+function ensureColumn(table, column, type) {
+    const database = db;
+    const exists = database.prepare(`PRAGMA table_info(${table})`).all()
+        .some((item) => item.name === column);
+    if (!exists)
+        database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+}
+function migrateEmbeddingModelColumn() {
+    const database = db;
+    const columns = database.prepare('PRAGMA table_info(databases)').all();
+    const hasLegacyAgentColumn = columns.some((item) => item.name === 'embedding_agent_id');
+    if (!hasLegacyAgentColumn)
+        return;
+    database.exec(`
+    UPDATE databases
+    SET embedding_model_id = COALESCE(embedding_model_id, embedding_agent_id)
+    WHERE embedding_agent_id IS NOT NULL AND embedding_agent_id != ''
+  `);
+}
+function rowToDatabase(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        name: row.name,
+        description: row.description,
+        embeddingModelId: row.embedding_model_id || undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToNode(row) {
+    return {
+        id: row.id,
+        databaseId: row.database_id,
+        title: row.title,
+        icon: row.icon,
+        cover: row.cover,
+        content: row.content,
+        parentId: row.parent_id || null,
+        isTrash: !!row.is_trash,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToVersionRow(row) {
+    return {
+        id: row.id,
+        nodeId: row.node_id,
+        databaseId: row.database_id,
+        title: row.title,
+        patch: JSON.parse(row.patch_json),
+        oldHash: row.old_hash,
+        newHash: row.new_hash,
+        createdAt: row.created_at,
+    };
+}
+export function listDatabases(workspaceId) {
+    const database = openDb();
+    const rows = database.prepare('SELECT * FROM databases WHERE workspace_id = ? ORDER BY created_at ASC').all(workspaceId);
+    return rows.map(rowToDatabase);
+}
+export function getDatabase(workspaceId, databaseId) {
+    const database = openDb();
+    const row = database.prepare('SELECT * FROM databases WHERE workspace_id = ? AND id = ?').get(workspaceId, databaseId);
+    return row ? rowToDatabase(row) : null;
+}
+export function getDefaultDatabase(workspaceId) {
+    const existing = listDatabases(workspaceId)[0];
+    if (existing)
+        return existing;
+    return createDatabase(workspaceId, { name: 'Default Database' });
+}
+export function createDatabase(workspaceId, input) {
+    const database = openDb();
+    const id = input.id || uuid();
+    const now = Date.now();
+    database.prepare(`INSERT INTO databases (id, workspace_id, name, description, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`).run(id, workspaceId, input.name?.trim() || 'Untitled Database', input.description || '', now, now);
+    return getDatabase(workspaceId, id);
+}
+export function updateDatabase(workspaceId, databaseId, updates) {
+    const existing = getDatabase(workspaceId, databaseId);
+    if (!existing)
+        return null;
+    const database = openDb();
+    const merged = { ...existing, ...updates, updatedAt: Date.now() };
+    database.prepare('UPDATE databases SET name = ?, description = ?, embedding_model_id = ?, updated_at = ? WHERE workspace_id = ? AND id = ?').run(merged.name.trim() || 'Untitled Database', merged.description, merged.embeddingModelId ?? null, merged.updatedAt, workspaceId, databaseId);
+    return getDatabase(workspaceId, databaseId);
+}
+export function deleteDatabase(workspaceId, databaseId) {
+    const database = openDb();
+    database.prepare('DELETE FROM doc_nodes WHERE workspace_id = ? AND database_id = ?').run(workspaceId, databaseId);
+    database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').run(workspaceId, databaseId);
+    const result = database.prepare('DELETE FROM databases WHERE workspace_id = ? AND id = ?').run(workspaceId, databaseId);
+    if (result.changes > 0 && listDatabases(workspaceId).length === 0)
+        getDefaultDatabase(workspaceId);
+    return result.changes > 0;
+}
+export function listNodes(workspaceId, databaseId) {
+    const database = openDb();
+    const activeDatabaseId = databaseId ?? getDefaultDatabase(workspaceId).id;
+    const rows = database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND database_id = ? ORDER BY created_at ASC').all(workspaceId, activeDatabaseId);
+    return rows.map(rowToNode);
+}
+export function getNode(workspaceId, nodeId, databaseId) {
+    const database = openDb();
+    const row = databaseId
+        ? database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND id = ?').get(workspaceId, databaseId, nodeId)
+        : database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND id = ?').get(workspaceId, nodeId);
+    return row ? rowToNode(row) : null;
+}
+export function createNode(workspaceId, node) {
+    const database = openDb();
+    const databaseId = node.databaseId || getDefaultDatabase(workspaceId).id;
+    if (!getDatabase(workspaceId, databaseId))
+        throw new Error(`Database not found: ${databaseId}`);
+    const id = node.id || uuid();
+    const now = Date.now();
+    database.prepare(`INSERT INTO doc_nodes (id, workspace_id, database_id, title, icon, cover, content, parent_id, is_trash, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, workspaceId, databaseId, node.title || 'Untitled Document', node.icon || '\u{1F4DD}', node.cover || '', node.content || '', node.parentId ?? null, node.isTrash ? 1 : 0, node.createdAt || now, node.updatedAt || now);
+    return getNode(workspaceId, id, databaseId);
+}
+export function updateNode(workspaceId, nodeId, updates, databaseId) {
+    const existing = getNode(workspaceId, nodeId, databaseId);
+    if (!existing)
+        return null;
+    const database = openDb();
+    const merged = { ...existing, ...updates, updatedAt: Date.now() };
+    if (Object.hasOwn(updates, 'content') && merged.content !== existing.content) {
+        insertNodeVersion(database, workspaceId, existing, merged.content);
+    }
+    database.prepare(`UPDATE doc_nodes SET title = ?, icon = ?, cover = ?, content = ?, parent_id = ?, is_trash = ?, updated_at = ?
+     WHERE workspace_id = ? AND database_id = ? AND id = ?`).run(merged.title, merged.icon, merged.cover, merged.content, merged.parentId, merged.isTrash ? 1 : 0, merged.updatedAt, workspaceId, existing.databaseId, nodeId);
+    return getNode(workspaceId, nodeId, existing.databaseId);
+}
+export function listNodeVersions(workspaceId, nodeId, databaseId, limit = 50) {
+    const node = getNode(workspaceId, nodeId, databaseId);
+    if (!node)
+        return [];
+    const database = openDb();
+    const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.min(100, Math.trunc(limit))) : 50;
+    const rows = database.prepare(`SELECT * FROM doc_node_versions
+     WHERE workspace_id = ? AND database_id = ? AND node_id = ?
+     ORDER BY created_at DESC
+     LIMIT ?`).all(workspaceId, node.databaseId, nodeId, normalizedLimit);
+    const stored = rows.map(rowToVersionRow);
+    let after = node.content;
+    return stored.map((item) => {
+        const before = applyReversePatch(after, item.patch);
+        const version = {
+            id: item.id,
+            nodeId: item.nodeId,
+            databaseId: item.databaseId,
+            title: item.title,
+            patch: item.patch,
+            oldContent: before,
+            newContent: after,
+            createdAt: item.createdAt,
+        };
+        after = before;
+        return version;
+    });
+}
+export function deleteNode(workspaceId, nodeId, databaseId) {
+    const database = openDb();
+    const existing = getNode(workspaceId, nodeId, databaseId);
+    if (!existing)
+        return false;
+    database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ? AND node_id = ?')
+        .run(workspaceId, existing.databaseId, nodeId);
+    database.prepare('DELETE FROM doc_node_versions WHERE workspace_id = ? AND database_id = ? AND node_id = ?')
+        .run(workspaceId, existing.databaseId, nodeId);
+    const result = database.prepare('DELETE FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND id = ?').run(workspaceId, existing.databaseId, nodeId);
+    return result.changes > 0;
+}
+function insertNodeVersion(database, workspaceId, existing, nextContent) {
+    const patch = createContentPatch(existing.content, nextContent);
+    database.prepare(`INSERT INTO doc_node_versions
+      (id, workspace_id, database_id, node_id, title, patch_json, old_hash, new_hash, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(uuid(), workspaceId, existing.databaseId, existing.id, existing.title, JSON.stringify(patch), hashContent(existing.content), hashContent(nextContent), Date.now());
+}
+function createContentPatch(oldContent, newContent) {
+    let start = 0;
+    while (start < oldContent.length
+        && start < newContent.length
+        && oldContent[start] === newContent[start]) {
+        start++;
+    }
+    let oldEnd = oldContent.length;
+    let newEnd = newContent.length;
+    while (oldEnd > start
+        && newEnd > start
+        && oldContent[oldEnd - 1] === newContent[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    return {
+        start,
+        deleteText: oldContent.slice(start, oldEnd),
+        insertText: newContent.slice(start, newEnd),
+    };
+}
+function applyReversePatch(content, patch) {
+    const insertEnd = patch.start + patch.insertText.length;
+    return `${content.slice(0, patch.start)}${patch.deleteText}${content.slice(insertEnd)}`;
+}
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+export function moveNode(workspaceId, nodeId, newParentId, databaseId) {
+    return updateNode(workspaceId, nodeId, { parentId: newParentId }, databaseId);
+}
+export function trashNode(workspaceId, nodeId, databaseId) {
+    return updateNode(workspaceId, nodeId, { isTrash: true }, databaseId);
+}
+export function restoreNode(workspaceId, nodeId, databaseId) {
+    const node = getNode(workspaceId, nodeId, databaseId);
+    if (!node)
+        return null;
+    if (node.parentId) {
+        const parent = getNode(workspaceId, node.parentId, node.databaseId);
+        if (parent && parent.isTrash) {
+            return updateNode(workspaceId, nodeId, { isTrash: false, parentId: null }, node.databaseId);
+        }
+    }
+    return updateNode(workspaceId, nodeId, { isTrash: false }, node.databaseId);
+}
+export function getVectorStats(workspaceId, databaseId) {
+    const database = openDb();
+    const meta = getDatabase(workspaceId, databaseId);
+    const indexed = database.prepare('SELECT COUNT(*) AS count, MAX(updated_at) AS last_indexed_at FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').get(workspaceId, databaseId);
+    const nodes = database.prepare('SELECT COUNT(*) AS count FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND is_trash = 0').get(workspaceId, databaseId);
+    return {
+        databaseId,
+        embeddingModelId: meta?.embeddingModelId ?? null,
+        indexedCount: indexed.count,
+        nodeCount: nodes.count,
+        lastIndexedAt: indexed.last_indexed_at,
+    };
+}
+export function setDatabaseEmbeddingModel(workspaceId, databaseId, embeddingModelId) {
+    return updateDatabase(workspaceId, databaseId, { embeddingModelId: embeddingModelId ?? undefined });
+}
+export function upsertDatabaseEmbedding(workspaceId, databaseId, record) {
+    const database = openDb();
+    database.prepare(`INSERT INTO database_embeddings
+      (workspace_id, database_id, node_id, title, path, content, content_hash, embedding, model_id, agent_id, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(workspace_id, database_id, node_id) DO UPDATE SET
+      title = excluded.title,
+      path = excluded.path,
+      content = excluded.content,
+      content_hash = excluded.content_hash,
+      embedding = excluded.embedding,
+      model_id = excluded.model_id,
+      agent_id = excluded.agent_id,
+      updated_at = excluded.updated_at`).run(workspaceId, databaseId, record.nodeId, record.title, record.path, record.content, record.contentHash, JSON.stringify(record.embedding), record.modelId, record.agentId, Date.now());
+}
+export function deleteStaleDatabaseEmbeddings(workspaceId, databaseId, activeNodeIds) {
+    const database = openDb();
+    if (activeNodeIds.length === 0) {
+        const result = database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ?')
+            .run(workspaceId, databaseId);
+        return result.changes;
+    }
+    const placeholders = activeNodeIds.map(() => '?').join(',');
+    const result = database.prepare(`DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ? AND node_id NOT IN (${placeholders})`).run(workspaceId, databaseId, ...activeNodeIds);
+    return result.changes;
+}
+export function listDatabaseEmbeddings(workspaceId, databaseId) {
+    const database = openDb();
+    const rows = database.prepare('SELECT node_id, title, path, content, embedding, updated_at FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').all(workspaceId, databaseId);
+    return rows.map((row) => ({
+        nodeId: row.node_id,
+        title: row.title,
+        path: row.path,
+        content: row.content,
+        score: 0,
+        updatedAt: row.updated_at,
+        embedding: JSON.parse(row.embedding),
+    }));
+}
+//# sourceMappingURL=database-store.js.map

package/dist/storage/hook-store.js

@@ -0,0 +1,55 @@
+import { join } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { getDataDir, ensureDir, readJsonFile, writeJsonFile, deleteFile } from './json-store.js';
+function workspaceDir(id) {
+    return join(getDataDir(), 'workspaces', id);
+}
+function hooksDir(wsId) {
+    return join(workspaceDir(wsId), 'hooks');
+}
+function hookPath(wsId, name) {
+    return join(hooksDir(wsId), `${name}.hook.json`);
+}
+export function listHooks(wsId) {
+    const dir = hooksDir(wsId);
+    try {
+        const files = readdirSync(dir);
+        return files
+            .filter(f => f.endsWith('.hook.json'))
+            .map(f => readJsonFile(join(dir, f)))
+            .filter((h) => h !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function getHook(wsId, name) {
+    return readJsonFile(hookPath(wsId, name));
+}
+export function saveHook(wsId, config) {
+    ensureDir(hooksDir(wsId));
+    writeJsonFile(hookPath(wsId, config.name), config);
+}
+export function deleteHook(wsId, name) {
+    deleteFile(hookPath(wsId, name));
+}
+export function uploadHook(wsId, jsonString) {
+    const parsed = JSON.parse(jsonString);
+    if (!parsed.name || typeof parsed.name !== 'string') {
+        throw new Error('Hook must have a "name" string field');
+    }
+    if (!parsed.hooks || typeof parsed.hooks !== 'object') {
+        parsed.hooks = { PreToolUse: [], PostToolUse: [] };
+    }
+    if (parsed.enabled === undefined)
+        parsed.enabled = true;
+    saveHook(wsId, parsed);
+    return parsed;
+}
+export function applyToWorkspace(sourceWsId, name, targetWsId) {
+    const config = getHook(sourceWsId, name);
+    if (!config)
+        throw new Error(`Hook "${name}" not found in workspace ${sourceWsId}`);
+    saveHook(targetWsId, config);
+}
+//# sourceMappingURL=hook-store.js.map