@hasna/prompts 0.1.0

package/dist/index.js

@@ -0,0 +1,737 @@
+// @bun
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+var _db = null;
+function getDbPath() {
+  if (process.env["PROMPTS_DB_PATH"]) {
+    return process.env["PROMPTS_DB_PATH"];
+  }
+  if (process.env["PROMPTS_DB_SCOPE"] === "project") {
+    let dir = process.cwd();
+    while (true) {
+      const candidate = join(dir, ".prompts", "prompts.db");
+      if (existsSync(join(dir, ".git"))) {
+        return candidate;
+      }
+      const parent = join(dir, "..");
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".prompts", "prompts.db");
+}
+function getDatabase() {
+  if (_db)
+    return _db;
+  const dbPath = getDbPath();
+  if (dbPath !== ":memory:") {
+    const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+    if (dir && !existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+  _db = db;
+  return db;
+}
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  const applied = new Set(db.query("SELECT name FROM _migrations").all().map((r) => r.name));
+  const migrations = [
+    {
+      name: "001_initial",
+      sql: `
+        CREATE TABLE IF NOT EXISTS collections (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          description TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        INSERT OR IGNORE INTO collections (id, name, description, created_at)
+        VALUES ('default', 'default', 'Default collection', datetime('now'));
+
+        CREATE TABLE IF NOT EXISTS prompts (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          slug TEXT NOT NULL UNIQUE,
+          title TEXT NOT NULL,
+          body TEXT NOT NULL,
+          description TEXT,
+          collection TEXT NOT NULL DEFAULT 'default' REFERENCES collections(name) ON UPDATE CASCADE,
+          tags TEXT NOT NULL DEFAULT '[]',
+          variables TEXT NOT NULL DEFAULT '[]',
+          is_template INTEGER NOT NULL DEFAULT 0,
+          source TEXT NOT NULL DEFAULT 'manual',
+          version INTEGER NOT NULL DEFAULT 1,
+          use_count INTEGER NOT NULL DEFAULT 0,
+          last_used_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS prompt_versions (
+          id TEXT PRIMARY KEY,
+          prompt_id TEXT NOT NULL REFERENCES prompts(id) ON DELETE CASCADE,
+          body TEXT NOT NULL,
+          version INTEGER NOT NULL,
+          changed_by TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS agents (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          description TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_prompts_collection ON prompts(collection);
+        CREATE INDEX IF NOT EXISTS idx_prompts_source ON prompts(source);
+        CREATE INDEX IF NOT EXISTS idx_prompts_is_template ON prompts(is_template);
+        CREATE INDEX IF NOT EXISTS idx_prompts_use_count ON prompts(use_count DESC);
+        CREATE INDEX IF NOT EXISTS idx_prompts_last_used ON prompts(last_used_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_versions_prompt_id ON prompt_versions(prompt_id);
+      `
+    },
+    {
+      name: "002_fts5",
+      sql: `
+        CREATE VIRTUAL TABLE IF NOT EXISTS prompts_fts USING fts5(
+          name,
+          slug,
+          title,
+          body,
+          description,
+          tags,
+          content='prompts',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS prompts_fts_insert AFTER INSERT ON prompts BEGIN
+          INSERT INTO prompts_fts(rowid, name, slug, title, body, description, tags)
+          VALUES (new.rowid, new.name, new.slug, new.title, new.body, COALESCE(new.description,''), new.tags);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS prompts_fts_update AFTER UPDATE ON prompts BEGIN
+          INSERT INTO prompts_fts(prompts_fts, rowid, name, slug, title, body, description, tags)
+          VALUES ('delete', old.rowid, old.name, old.slug, old.title, old.body, COALESCE(old.description,''), old.tags);
+          INSERT INTO prompts_fts(rowid, name, slug, title, body, description, tags)
+          VALUES (new.rowid, new.name, new.slug, new.title, new.body, COALESCE(new.description,''), new.tags);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS prompts_fts_delete AFTER DELETE ON prompts BEGIN
+          INSERT INTO prompts_fts(prompts_fts, rowid, name, slug, title, body, description, tags)
+          VALUES ('delete', old.rowid, old.name, old.slug, old.title, old.body, COALESCE(old.description,''), old.tags);
+        END;
+      `
+    }
+  ];
+  for (const migration of migrations) {
+    if (applied.has(migration.name))
+      continue;
+    db.exec(migration.sql);
+    db.run("INSERT INTO _migrations (name) VALUES (?)", [migration.name]);
+  }
+}
+function hasFts(db) {
+  return db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name='prompts_fts'").get() !== null;
+}
+function resolvePrompt(db, idOrSlug) {
+  const byId = db.query("SELECT id FROM prompts WHERE id = ?").get(idOrSlug);
+  if (byId)
+    return byId.id;
+  const bySlug = db.query("SELECT id FROM prompts WHERE slug = ?").get(idOrSlug);
+  if (bySlug)
+    return bySlug.id;
+  const byPrefix = db.query("SELECT id FROM prompts WHERE id LIKE ? LIMIT 2").all(`${idOrSlug}%`);
+  if (byPrefix.length === 1 && byPrefix[0])
+    return byPrefix[0].id;
+  return null;
+}
+
+// src/lib/ids.ts
+function generateSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 80);
+}
+function uniqueSlug(baseSlug) {
+  const db = getDatabase();
+  let slug = baseSlug;
+  let i = 2;
+  while (db.query("SELECT 1 FROM prompts WHERE slug = ?").get(slug)) {
+    slug = `${baseSlug}-${i}`;
+    i++;
+  }
+  return slug;
+}
+function generatePromptId() {
+  const db = getDatabase();
+  const row = db.query("SELECT id FROM prompts ORDER BY rowid DESC LIMIT 1").get();
+  let next = 1;
+  if (row) {
+    const match = row.id.match(/PRMT-(\d+)/);
+    if (match && match[1]) {
+      next = parseInt(match[1], 10) + 1;
+    }
+  }
+  return `PRMT-${String(next).padStart(5, "0")}`;
+}
+function generateId(prefix) {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = prefix + "-";
+  for (let i = 0;i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+
+// src/db/collections.ts
+function rowToCollection(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    description: row["description"] ?? null,
+    prompt_count: row["prompt_count"] ?? 0,
+    created_at: row["created_at"]
+  };
+}
+function listCollections() {
+  const db = getDatabase();
+  const rows = db.query(`SELECT c.*, COUNT(p.id) as prompt_count
+       FROM collections c
+       LEFT JOIN prompts p ON p.collection = c.name
+       GROUP BY c.id
+       ORDER BY c.name`).all();
+  return rows.map(rowToCollection);
+}
+function getCollection(name) {
+  const db = getDatabase();
+  const row = db.query(`SELECT c.*, COUNT(p.id) as prompt_count
+       FROM collections c
+       LEFT JOIN prompts p ON p.collection = c.name
+       WHERE c.name = ?
+       GROUP BY c.id`).get(name);
+  if (!row)
+    return null;
+  return rowToCollection(row);
+}
+function ensureCollection(name, description) {
+  const db = getDatabase();
+  const existing = db.query("SELECT id FROM collections WHERE name = ?").get(name);
+  if (!existing) {
+    const id = generateId("COL");
+    db.run("INSERT INTO collections (id, name, description) VALUES (?, ?, ?)", [
+      id,
+      name,
+      description ?? null
+    ]);
+  }
+  return getCollection(name);
+}
+function movePrompt(promptIdOrSlug, targetCollection) {
+  const db = getDatabase();
+  ensureCollection(targetCollection);
+  const row = db.query("SELECT id FROM prompts WHERE id = ? OR slug = ?").get(promptIdOrSlug, promptIdOrSlug);
+  if (!row)
+    throw new Error(`Prompt not found: ${promptIdOrSlug}`);
+  db.run("UPDATE prompts SET collection = ?, updated_at = datetime('now') WHERE id = ?", [
+    targetCollection,
+    row.id
+  ]);
+}
+
+// src/lib/template.ts
+var VAR_PATTERN = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\|\s*(.*?)\s*)?\}\}/g;
+function extractVariables(body) {
+  const vars = new Set;
+  const pattern = new RegExp(VAR_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    if (match[1])
+      vars.add(match[1]);
+  }
+  return Array.from(vars);
+}
+function extractVariableInfo(body) {
+  const seen = new Map;
+  const pattern = new RegExp(VAR_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    const name = match[1];
+    if (!name)
+      continue;
+    const defaultVal = match[2] !== undefined ? match[2] : null;
+    if (!seen.has(name)) {
+      seen.set(name, { name, default: defaultVal, required: defaultVal === null });
+    }
+  }
+  return Array.from(seen.values());
+}
+function renderTemplate(body, vars) {
+  const missing = [];
+  const usedDefaults = [];
+  const rendered = body.replace(VAR_PATTERN, (_match, name, defaultVal) => {
+    if (name in vars)
+      return vars[name] ?? "";
+    if (defaultVal !== undefined) {
+      usedDefaults.push(name);
+      return defaultVal;
+    }
+    missing.push(name);
+    return _match;
+  });
+  return { rendered, missing_vars: missing, used_defaults: usedDefaults };
+}
+function validateVars(body, provided) {
+  const infos = extractVariableInfo(body);
+  const required = infos.filter((v) => v.required).map((v) => v.name);
+  const optional = infos.filter((v) => !v.required).map((v) => v.name);
+  const all = infos.map((v) => v.name);
+  const missing = required.filter((v) => !(v in provided));
+  const extra = Object.keys(provided).filter((v) => !all.includes(v));
+  return { missing, extra, optional };
+}
+
+// src/types/index.ts
+class PromptNotFoundError extends Error {
+  constructor(id) {
+    super(`Prompt not found: ${id}`);
+    this.name = "PromptNotFoundError";
+  }
+}
+
+class VersionConflictError extends Error {
+  constructor(id) {
+    super(`Version conflict on prompt: ${id}`);
+    this.name = "VersionConflictError";
+  }
+}
+
+class DuplicateSlugError extends Error {
+  constructor(slug) {
+    super(`A prompt with slug "${slug}" already exists`);
+    this.name = "DuplicateSlugError";
+  }
+}
+
+class TemplateRenderError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TemplateRenderError";
+  }
+}
+
+// src/db/prompts.ts
+function rowToPrompt(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    slug: row["slug"],
+    title: row["title"],
+    body: row["body"],
+    description: row["description"] ?? null,
+    collection: row["collection"],
+    tags: JSON.parse(row["tags"] || "[]"),
+    variables: JSON.parse(row["variables"] || "[]"),
+    is_template: Boolean(row["is_template"]),
+    source: row["source"],
+    version: row["version"],
+    use_count: row["use_count"],
+    last_used_at: row["last_used_at"] ?? null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function createPrompt(input) {
+  const db = getDatabase();
+  const slug = input.slug ? input.slug : uniqueSlug(generateSlug(input.title));
+  if (input.slug) {
+    const existing = db.query("SELECT id FROM prompts WHERE slug = ?").get(input.slug);
+    if (existing)
+      throw new DuplicateSlugError(input.slug);
+  }
+  const id = generatePromptId();
+  const name = input.name || input.title;
+  const collection = input.collection || "default";
+  ensureCollection(collection);
+  const tags = JSON.stringify(input.tags || []);
+  const source = input.source || "manual";
+  const vars = extractVariables(input.body);
+  const variables = JSON.stringify(vars.map((v) => ({ name: v, required: true })));
+  const is_template = vars.length > 0 ? 1 : 0;
+  db.run(`INSERT INTO prompts (id, name, slug, title, body, description, collection, tags, variables, is_template, source)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, name, slug, input.title, input.body, input.description ?? null, collection, tags, variables, is_template, source]);
+  db.run(`INSERT INTO prompt_versions (id, prompt_id, body, version, changed_by)
+     VALUES (?, ?, ?, 1, ?)`, [generateId("VER"), id, input.body, input.changed_by ?? null]);
+  return getPrompt(id);
+}
+function getPrompt(idOrSlug) {
+  const db = getDatabase();
+  const id = resolvePrompt(db, idOrSlug);
+  if (!id)
+    return null;
+  const row = db.query("SELECT * FROM prompts WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToPrompt(row);
+}
+function requirePrompt(idOrSlug) {
+  const prompt = getPrompt(idOrSlug);
+  if (!prompt)
+    throw new PromptNotFoundError(idOrSlug);
+  return prompt;
+}
+function listPrompts(filter = {}) {
+  const db = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.collection) {
+    conditions.push("collection = ?");
+    params.push(filter.collection);
+  }
+  if (filter.is_template !== undefined) {
+    conditions.push("is_template = ?");
+    params.push(filter.is_template ? 1 : 0);
+  }
+  if (filter.source) {
+    conditions.push("source = ?");
+    params.push(filter.source);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    const tagConditions = filter.tags.map(() => "tags LIKE ?");
+    conditions.push(`(${tagConditions.join(" OR ")})`);
+    for (const tag of filter.tags) {
+      params.push(`%"${tag}"%`);
+    }
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ?? 100;
+  const offset = filter.offset ?? 0;
+  const rows = db.query(`SELECT * FROM prompts ${where} ORDER BY use_count DESC, updated_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return rows.map(rowToPrompt);
+}
+function updatePrompt(idOrSlug, input) {
+  const db = getDatabase();
+  const prompt = requirePrompt(idOrSlug);
+  const newBody = input.body ?? prompt.body;
+  const vars = extractVariables(newBody);
+  const variables = JSON.stringify(vars.map((v) => ({ name: v, required: true })));
+  const is_template = vars.length > 0 ? 1 : 0;
+  const updated = db.run(`UPDATE prompts SET
+      title = COALESCE(?, title),
+      body = COALESCE(?, body),
+      description = COALESCE(?, description),
+      collection = COALESCE(?, collection),
+      tags = COALESCE(?, tags),
+      variables = ?,
+      is_template = ?,
+      version = version + 1,
+      updated_at = datetime('now')
+     WHERE id = ? AND version = ?`, [
+    input.title ?? null,
+    input.body ?? null,
+    input.description ?? null,
+    input.collection ?? null,
+    input.tags ? JSON.stringify(input.tags) : null,
+    variables,
+    is_template,
+    prompt.id,
+    prompt.version
+  ]);
+  if (updated.changes === 0)
+    throw new VersionConflictError(prompt.id);
+  if (input.body && input.body !== prompt.body) {
+    db.run(`INSERT INTO prompt_versions (id, prompt_id, body, version, changed_by)
+       VALUES (?, ?, ?, ?, ?)`, [generateId("VER"), prompt.id, input.body, prompt.version + 1, input.changed_by ?? null]);
+  }
+  return requirePrompt(prompt.id);
+}
+function deletePrompt(idOrSlug) {
+  const db = getDatabase();
+  const prompt = requirePrompt(idOrSlug);
+  db.run("DELETE FROM prompts WHERE id = ?", [prompt.id]);
+}
+function usePrompt(idOrSlug) {
+  const db = getDatabase();
+  const prompt = requirePrompt(idOrSlug);
+  db.run("UPDATE prompts SET use_count = use_count + 1, last_used_at = datetime('now') WHERE id = ?", [prompt.id]);
+  return requirePrompt(prompt.id);
+}
+function upsertPrompt(input) {
+  const db = getDatabase();
+  const slug = input.slug || generateSlug(input.title);
+  const existing = db.query("SELECT id FROM prompts WHERE slug = ?").get(slug);
+  if (existing) {
+    const prompt2 = updatePrompt(existing.id, {
+      title: input.title,
+      body: input.body,
+      description: input.description,
+      collection: input.collection,
+      tags: input.tags,
+      changed_by: input.changed_by
+    });
+    return { prompt: prompt2, created: false };
+  }
+  const prompt = createPrompt({ ...input, slug });
+  return { prompt, created: true };
+}
+function getPromptStats() {
+  const db = getDatabase();
+  const total = db.query("SELECT COUNT(*) as n FROM prompts").get().n;
+  const templates = db.query("SELECT COUNT(*) as n FROM prompts WHERE is_template = 1").get().n;
+  const collections = db.query("SELECT COUNT(DISTINCT collection) as n FROM prompts").get().n;
+  const mostUsed = db.query("SELECT id, name, slug, title, use_count FROM prompts WHERE use_count > 0 ORDER BY use_count DESC LIMIT 10").all();
+  const recentlyUsed = db.query("SELECT id, name, slug, title, last_used_at FROM prompts WHERE last_used_at IS NOT NULL ORDER BY last_used_at DESC LIMIT 10").all();
+  const byCollection = db.query("SELECT collection, COUNT(*) as count FROM prompts GROUP BY collection ORDER BY count DESC").all();
+  const bySource = db.query("SELECT source, COUNT(*) as count FROM prompts GROUP BY source ORDER BY count DESC").all();
+  return { total_prompts: total, total_templates: templates, total_collections: collections, most_used: mostUsed, recently_used: recentlyUsed, by_collection: byCollection, by_source: bySource };
+}
+// src/db/versions.ts
+function rowToVersion(row) {
+  return {
+    id: row["id"],
+    prompt_id: row["prompt_id"],
+    body: row["body"],
+    version: row["version"],
+    changed_by: row["changed_by"] ?? null,
+    created_at: row["created_at"]
+  };
+}
+function listVersions(promptId) {
+  const db = getDatabase();
+  const rows = db.query("SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY version DESC").all(promptId);
+  return rows.map(rowToVersion);
+}
+function getVersion(promptId, version) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM prompt_versions WHERE prompt_id = ? AND version = ?").get(promptId, version);
+  if (!row)
+    return null;
+  return rowToVersion(row);
+}
+function restoreVersion(promptId, version, changedBy) {
+  const db = getDatabase();
+  const ver = getVersion(promptId, version);
+  if (!ver)
+    throw new PromptNotFoundError(`${promptId}@v${version}`);
+  const current = db.query("SELECT version FROM prompts WHERE id = ?").get(promptId);
+  if (!current)
+    throw new PromptNotFoundError(promptId);
+  const newVersion = current.version + 1;
+  db.run(`UPDATE prompts SET body = ?, version = ?, updated_at = datetime('now'),
+     is_template = (CASE WHEN body LIKE '%{{%' THEN 1 ELSE 0 END)
+     WHERE id = ?`, [ver.body, newVersion, promptId]);
+  db.run(`INSERT INTO prompt_versions (id, prompt_id, body, version, changed_by)
+     VALUES (?, ?, ?, ?, ?)`, [generateId("VER"), promptId, ver.body, newVersion, changedBy ?? null]);
+}
+// src/db/agents.ts
+function rowToAgent(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    description: row["description"] ?? null,
+    created_at: row["created_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function registerAgent(name, description) {
+  const db = getDatabase();
+  const existing = db.query("SELECT * FROM agents WHERE name = ?").get(name);
+  if (existing) {
+    db.run("UPDATE agents SET last_seen_at = datetime('now'), description = COALESCE(?, description) WHERE name = ?", [
+      description ?? null,
+      name
+    ]);
+    return rowToAgent(db.query("SELECT * FROM agents WHERE name = ?").get(name));
+  }
+  const id = generateId("AGT");
+  db.run("INSERT INTO agents (id, name, description) VALUES (?, ?, ?)", [id, name, description ?? null]);
+  return rowToAgent(db.query("SELECT * FROM agents WHERE id = ?").get(id));
+}
+function listAgents() {
+  const db = getDatabase();
+  const rows = db.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(rowToAgent);
+}
+// src/lib/search.ts
+function rowToSearchResult(row, snippet) {
+  return {
+    prompt: {
+      id: row["id"],
+      name: row["name"],
+      slug: row["slug"],
+      title: row["title"],
+      body: row["body"],
+      description: row["description"] ?? null,
+      collection: row["collection"],
+      tags: JSON.parse(row["tags"] || "[]"),
+      variables: JSON.parse(row["variables"] || "[]"),
+      is_template: Boolean(row["is_template"]),
+      source: row["source"],
+      version: row["version"],
+      use_count: row["use_count"],
+      last_used_at: row["last_used_at"] ?? null,
+      created_at: row["created_at"],
+      updated_at: row["updated_at"]
+    },
+    score: row["score"] ?? 1,
+    snippet
+  };
+}
+function escapeFtsQuery(q) {
+  return q.trim().split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, '""')}"*`).join(" ");
+}
+function searchPrompts(query, filter = {}) {
+  const db = getDatabase();
+  if (!query.trim()) {
+    const prompts = listPrompts(filter);
+    return prompts.map((p) => ({ prompt: p, score: 1 }));
+  }
+  if (hasFts(db)) {
+    const ftsQuery = escapeFtsQuery(query);
+    const conditions = [];
+    const params = [];
+    if (filter.collection) {
+      conditions.push("p.collection = ?");
+      params.push(filter.collection);
+    }
+    if (filter.is_template !== undefined) {
+      conditions.push("p.is_template = ?");
+      params.push(filter.is_template ? 1 : 0);
+    }
+    if (filter.source) {
+      conditions.push("p.source = ?");
+      params.push(filter.source);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      const tagConds = filter.tags.map(() => "p.tags LIKE ?");
+      conditions.push(`(${tagConds.join(" OR ")})`);
+      for (const tag of filter.tags)
+        params.push(`%"${tag}"%`);
+    }
+    const where = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit ?? 50;
+    const offset = filter.offset ?? 0;
+    try {
+      const rows2 = db.query(`SELECT p.*, bm25(prompts_fts) as score,
+            snippet(prompts_fts, 2, '[', ']', '...', 10) as snippet
+           FROM prompts p
+           INNER JOIN prompts_fts ON prompts_fts.rowid = p.rowid
+           WHERE prompts_fts MATCH ?
+           ${where}
+           ORDER BY bm25(prompts_fts)
+           LIMIT ? OFFSET ?`).all(ftsQuery, ...params, limit, offset);
+      return rows2.map((r) => rowToSearchResult(r, r["snippet"]));
+    } catch {}
+  }
+  const like = `%${query}%`;
+  const rows = db.query(`SELECT *, 1 as score FROM prompts
+       WHERE (name LIKE ? OR slug LIKE ? OR title LIKE ? OR body LIKE ? OR description LIKE ? OR tags LIKE ?)
+       ORDER BY use_count DESC, updated_at DESC
+       LIMIT ? OFFSET ?`).all(like, like, like, like, like, like, filter.limit ?? 50, filter.offset ?? 0);
+  return rows.map((r) => rowToSearchResult(r));
+}
+function findSimilar(promptId, limit = 5) {
+  const db = getDatabase();
+  const prompt = db.query("SELECT * FROM prompts WHERE id = ?").get(promptId);
+  if (!prompt)
+    return [];
+  const tags = JSON.parse(prompt["tags"] || "[]");
+  const collection = prompt["collection"];
+  if (tags.length === 0) {
+    const rows = db.query("SELECT *, 1 as score FROM prompts WHERE collection = ? AND id != ? ORDER BY use_count DESC LIMIT ?").all(collection, promptId, limit);
+    return rows.map((r) => rowToSearchResult(r));
+  }
+  const allRows = db.query("SELECT * FROM prompts WHERE id != ?").all(promptId);
+  const scored = allRows.map((row) => {
+    const rowTags = JSON.parse(row["tags"] || "[]");
+    const overlap = rowTags.filter((t) => tags.includes(t)).length;
+    const sameCollection = row["collection"] === collection ? 1 : 0;
+    return { row, score: overlap * 2 + sameCollection };
+  });
+  return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => rowToSearchResult(s.row, undefined));
+}
+// src/lib/importer.ts
+function importFromJson(items, changedBy) {
+  let created = 0;
+  let updated = 0;
+  const errors = [];
+  for (const item of items) {
+    try {
+      const input = {
+        title: item.title,
+        body: item.body,
+        slug: item.slug,
+        description: item.description,
+        collection: item.collection,
+        tags: item.tags,
+        source: "imported",
+        changed_by: changedBy
+      };
+      const { created: wasCreated } = upsertPrompt(input);
+      if (wasCreated)
+        created++;
+      else
+        updated++;
+    } catch (e) {
+      errors.push({ item: item.title, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { created, updated, errors };
+}
+function exportToJson(collection) {
+  const prompts = listPrompts({ collection, limit: 1e4 });
+  return { prompts, exported_at: new Date().toISOString(), collection };
+}
+export {
+  validateVars,
+  usePrompt,
+  upsertPrompt,
+  updatePrompt,
+  uniqueSlug,
+  searchPrompts,
+  restoreVersion,
+  requirePrompt,
+  renderTemplate,
+  registerAgent,
+  movePrompt,
+  listVersions,
+  listPrompts,
+  listCollections,
+  listAgents,
+  importFromJson,
+  getVersion,
+  getPromptStats,
+  getPrompt,
+  getDbPath,
+  getDatabase,
+  getCollection,
+  generateSlug,
+  generatePromptId,
+  findSimilar,
+  extractVariables,
+  extractVariableInfo,
+  exportToJson,
+  ensureCollection,
+  deletePrompt,
+  createPrompt,
+  VersionConflictError,
+  TemplateRenderError,
+  PromptNotFoundError,
+  DuplicateSlugError
+};