@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-GAB6UW52.js

@@ -0,0 +1,1087 @@
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-XQPEWJPI.js";
+import {
+  applySqlitePragmas
+} from "./chunk-HEP3ILP4.js";
+import {
+  resolveBuildDirFromContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/prompts/store.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+// src/core/storage/activation-primitive.ts
+function performActivation(db, input) {
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const tx = db.transaction(() => {
+    db.prepare(
+      `UPDATE prompt_versions
+         SET is_active = 0, deactivated_at = ?
+       WHERE prompt_id = ? AND is_active = 1 AND id <> ?`
+    ).run(now, input.promptId, input.versionId);
+    db.prepare(
+      `UPDATE prompt_versions
+         SET is_active = 1,
+             activated_at = CASE
+               WHEN is_active = 1 THEN activated_at
+               ELSE ?
+             END
+       WHERE prompt_id = ? AND id = ?`
+    ).run(now, input.promptId, input.versionId);
+    db.prepare(
+      `UPDATE prompts
+         SET active_version_id = ?, current_version = ?, updated_at = ?
+       WHERE id = ?`
+    ).run(input.versionId, input.versionId, now, input.promptId);
+  });
+  tx();
+}
+
+// src/core/storage/prompt-version-indexes.ts
+var PROMPT_VERSION_INDEXES_SQL = "      CREATE INDEX IF NOT EXISTS idx_versions_prompt ON prompt_versions(prompt_id);\n      CREATE INDEX IF NOT EXISTS idx_versions_active ON prompt_versions(prompt_id, is_active);";
+
+// src/prompts/legacy-version-columns.ts
+function hasVersionColumn(db, column) {
+  const columns = db.prepare("PRAGMA table_info(prompt_versions)").all();
+  return columns.some((entry) => entry.name === column);
+}
+function readInlineVersionContent(db, promptId, versionId) {
+  if (!hasVersionColumn(db, "content")) return void 0;
+  const row = db.prepare("SELECT content FROM prompt_versions WHERE prompt_id = ? AND id = ?").get(promptId, versionId);
+  return typeof row?.content === "string" ? row.content : void 0;
+}
+function readVersionOrder(db, promptId) {
+  const numberColumn = hasVersionColumn(db, "version_number") ? "version_number" : "NULL";
+  return db.prepare(
+    `SELECT id, ${numberColumn} AS versionNumber FROM prompt_versions WHERE prompt_id = ? ORDER BY rowid ASC`
+  ).all(promptId);
+}
+
+// src/prompts/store.ts
+var PROMPT_ID_PATTERN = /^[a-z0-9-]+$/;
+var LEGACY_PROMPT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+var VERSION_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+var LIKE_WILDCARD_CHARACTERS = /[%_]/g;
+function escapeLikePattern(value) {
+  return value.replace(LIKE_WILDCARD_CHARACTERS, "\\$&");
+}
+function assertSafePromptId(promptId) {
+  if (!PROMPT_ID_PATTERN.test(promptId) && !LEGACY_PROMPT_ID_PATTERN.test(promptId)) {
+    throw new Error(
+      "Prompt ID must be a safe identifier (lowercase letters, numbers, hyphens; legacy underscores are readable)"
+    );
+  }
+  if (promptId.includes("/") || promptId.includes("\\")) {
+    throw new Error("Prompt ID cannot contain path separators");
+  }
+}
+function assertSafeVersionId(versionId) {
+  if (!VERSION_ID_PATTERN.test(versionId)) {
+    throw new Error(
+      "Version ID must start with an alphanumeric character and may only include dots, underscores, or hyphens"
+    );
+  }
+  if (versionId.includes("/") || versionId.includes("\\")) {
+    throw new Error("Version ID cannot contain path separators");
+  }
+}
+function atomicWriteTextSync(filePath, content) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = path.join(
+    dir,
+    `.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(8).toString("hex")}`
+  );
+  let fd;
+  try {
+    fd = fs.openSync(tempPath, "wx");
+    fs.writeFileSync(fd, content, "utf8");
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fd = void 0;
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+var PromptStore = class {
+  buildDir;
+  promptsDir;
+  dbDir;
+  activeDir;
+  archivedDir;
+  templatesDir;
+  db;
+  constructor(options = {}) {
+    this.buildDir = resolveBuildDirFromContext(options.buildDir);
+    this.promptsDir = path.join(this.buildDir, "prompts");
+    this.dbDir = path.join(this.promptsDir, "db");
+    this.activeDir = path.join(this.promptsDir, "active");
+    this.archivedDir = path.join(this.promptsDir, "archived");
+    this.templatesDir = path.join(this.promptsDir, "templates");
+    this.ensureDirectories();
+    if (!sqlite_wrapper_default) {
+      throw new Error("Database constructor not available");
+    }
+    const DatabaseConstructor = sqlite_wrapper_default;
+    this.db = new DatabaseConstructor(path.join(this.dbDir, "prompts.db"));
+    if (this.db.defaultSafeIntegers) {
+      this.db.defaultSafeIntegers(false);
+    }
+    applySqlitePragmas(this.db, { foreignKeys: true });
+    this.initSchema();
+  }
+  /**
+   * Ensure all required directories exist
+   */
+  ensureDirectories() {
+    [this.promptsDir, this.dbDir, this.activeDir, this.archivedDir, this.templatesDir].forEach(
+      (dir) => {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+      }
+    );
+  }
+  /**
+   * Initialize database schema
+   */
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL,
+        category TEXT NOT NULL,
+        status TEXT NOT NULL,
+        variant TEXT,
+        tags TEXT NOT NULL,
+        auto_opt_in INTEGER DEFAULT 0,
+        current_version TEXT NOT NULL,
+        active_version_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        archived_at TEXT,
+        usage_count INTEGER DEFAULT 0,
+        last_used_at TEXT,
+        UNIQUE(name, category)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_prompts_category ON prompts(category);
+      CREATE INDEX IF NOT EXISTS idx_prompts_updated ON prompts(updated_at DESC);
+    `);
+    const promptColumns = this.db.prepare("PRAGMA table_info(prompts)").all();
+    const promptColumnNames = promptColumns.map((col) => col.name);
+    if (!promptColumnNames.includes("auto_opt_in")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN auto_opt_in INTEGER DEFAULT 0");
+    }
+    if (!promptColumnNames.includes("active_version_id")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN active_version_id TEXT");
+    }
+    if (!promptColumnNames.includes("current_version")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN current_version TEXT");
+      this.db.exec(
+        "UPDATE prompts SET current_version = active_version_id WHERE current_version IS NULL"
+      );
+    }
+    if (!promptColumnNames.includes("status")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN status TEXT NOT NULL DEFAULT 'active'");
+    }
+    if (!promptColumnNames.includes("variant")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN variant TEXT");
+    }
+    if (!promptColumnNames.includes("tags")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'");
+    }
+    if (!promptColumnNames.includes("archived_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN archived_at TEXT");
+    }
+    if (!promptColumnNames.includes("usage_count")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN usage_count INTEGER DEFAULT 0");
+    }
+    if (!promptColumnNames.includes("last_used_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN last_used_at TEXT");
+    }
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_status ON prompts(status)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_variant ON prompts(variant)");
+    this.db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_prompts_active_version ON prompts(active_version_id)"
+    );
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_versions (
+        id TEXT NOT NULL,
+        prompt_id TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        changelog TEXT,
+        author TEXT,
+        is_active INTEGER DEFAULT 0,
+        is_generated INTEGER DEFAULT 0,
+        generation_model TEXT,
+        generation_prompt TEXT,
+        created_at TEXT NOT NULL,
+        activated_at TEXT,
+        deactivated_at TEXT,
+        parent_version_id TEXT,
+        mutation_type TEXT,
+        optimization_metadata TEXT,
+        generated_by TEXT,
+        activated_by TEXT,
+        performance_score REAL,
+        PRIMARY KEY (prompt_id, id),
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE
+      );
+
+      ${PROMPT_VERSION_INDEXES_SQL}
+    `);
+    const versionColumns = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+    const versionColumnNames = versionColumns.map((col) => col.name);
+    if (!versionColumnNames.includes("content_hash")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN content_hash TEXT NOT NULL DEFAULT ''");
+    }
+    if (versionColumnNames.includes("content")) {
+      const legacyRows = this.db.prepare("SELECT prompt_id, id, content, content_hash FROM prompt_versions").all();
+      const invalidHash = /^(?:sha256:)?[a-f0-9]{64}$/i;
+      const updateHash = this.db.prepare(
+        "UPDATE prompt_versions SET content_hash = ? WHERE prompt_id = ? AND id = ?"
+      );
+      const applyBackfill = () => {
+        for (const row of legacyRows) {
+          if (typeof row.content !== "string" || invalidHash.test(row.content_hash.trim()))
+            continue;
+          updateHash.run(this.hashContent(row.content), row.prompt_id, row.id);
+        }
+      };
+      if (this.db.transaction) {
+        this.db.transaction(applyBackfill)();
+      } else {
+        applyBackfill();
+      }
+    }
+    if (!versionColumnNames.includes("changelog")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN changelog TEXT");
+    }
+    if (!versionColumnNames.includes("author")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN author TEXT");
+    }
+    if (!versionColumnNames.includes("is_generated")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN is_generated INTEGER DEFAULT 0");
+    }
+    if (!versionColumnNames.includes("generation_model")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generation_model TEXT");
+    }
+    if (!versionColumnNames.includes("generation_prompt")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generation_prompt TEXT");
+    }
+    if (!versionColumnNames.includes("activated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN activated_at TEXT");
+    }
+    if (!versionColumnNames.includes("deactivated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN deactivated_at TEXT");
+    }
+    if (!versionColumnNames.includes("parent_version_id")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN parent_version_id TEXT");
+    }
+    if (!versionColumnNames.includes("mutation_type")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN mutation_type TEXT");
+    }
+    if (!versionColumnNames.includes("optimization_metadata")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN optimization_metadata TEXT");
+    }
+    if (!versionColumnNames.includes("generated_by")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generated_by TEXT");
+    }
+    if (!versionColumnNames.includes("activated_by")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN activated_by TEXT");
+    }
+    if (!versionColumnNames.includes("performance_score")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN performance_score REAL");
+    }
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_versions_hash ON prompt_versions(content_hash)");
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_versions_parent ON prompt_versions(parent_version_id);
+      CREATE INDEX IF NOT EXISTS idx_versions_lineage ON prompt_versions(prompt_id, parent_version_id);
+      CREATE INDEX IF NOT EXISTS idx_versions_mutation_type ON prompt_versions(mutation_type);
+      CREATE INDEX IF NOT EXISTS idx_versions_performance ON prompt_versions(performance_score DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_performance (
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        variant TEXT,
+        total_executions INTEGER DEFAULT 0,
+        successful_executions INTEGER DEFAULT 0,
+        failed_executions INTEGER DEFAULT 0,
+        success_rate REAL DEFAULT 0,
+        avg_completeness REAL DEFAULT 0,
+        avg_code_delivery_rate REAL DEFAULT 0,
+        avg_duration REAL DEFAULT 0,
+        min_completeness REAL DEFAULT 0,
+        max_completeness REAL DEFAULT 0,
+        std_dev_completeness REAL DEFAULT 0,
+        sample_size INTEGER DEFAULT 0,
+        first_execution_at TEXT,
+        last_execution_at TEXT,
+        calculated_at TEXT NOT NULL,
+        PRIMARY KEY (prompt_id, version_id, variant),
+        FOREIGN KEY (prompt_id, version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_performance_version ON prompt_performance(version_id);
+      CREATE INDEX IF NOT EXISTS idx_performance_variant ON prompt_performance(variant);
+      CREATE INDEX IF NOT EXISTS idx_performance_success_rate ON prompt_performance(success_rate DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_variants (
+        id TEXT PRIMARY KEY,
+        prompt_id TEXT NOT NULL,
+        base_version_id TEXT NOT NULL,
+        mutation_strategies TEXT NOT NULL,
+        success_rate REAL,
+        completeness REAL,
+        duration_ms INTEGER,
+        confidence REAL,
+        expected_improvement REAL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE,
+        FOREIGN KEY (prompt_id, base_version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_variants_prompt ON prompt_variants(prompt_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_variants_base_version ON prompt_variants(base_version_id);
+      CREATE INDEX IF NOT EXISTS idx_variants_performance ON prompt_variants(success_rate DESC, completeness DESC);
+      CREATE INDEX IF NOT EXISTS idx_variants_strategies ON prompt_variants(mutation_strategies);
+      CREATE INDEX IF NOT EXISTS idx_variants_confidence ON prompt_variants(confidence DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS activation_history (
+        id TEXT PRIMARY KEY,
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        activated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        activated_by TEXT,
+        reason TEXT,
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_activation_prompt_timeline ON activation_history(prompt_id, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_version ON activation_history(version_id, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_by ON activation_history(activated_by, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_recent ON activation_history(activated_at DESC);
+    `);
+  }
+  promptVersionsHasColumn(columnName) {
+    const columns = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+    return columns.some((column) => column.name === columnName);
+  }
+  nextLegacyVersionNumber(promptId) {
+    const row = this.db.prepare("SELECT MAX(version_number) as maxVersion FROM prompt_versions WHERE prompt_id = ?").get(promptId);
+    return (row?.maxVersion ?? 0) + 1;
+  }
+  createPrompt(inputOrId, name, description, category, variant, tags = []) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const data = typeof inputOrId === "object" ? {
+      id: inputOrId.id,
+      name: inputOrId.name,
+      description: inputOrId.description,
+      category: inputOrId.category,
+      status: inputOrId.status ?? "active",
+      variant: inputOrId.variant,
+      tags: inputOrId.tags ?? [],
+      currentVersion: inputOrId.currentVersion ?? "",
+      autoOptimize: inputOrId.autoOptimize ?? false
+    } : {
+      id: inputOrId,
+      name: name ?? "",
+      description: description ?? "",
+      category,
+      status: "active",
+      variant,
+      tags,
+      currentVersion: "",
+      autoOptimize: false
+    };
+    if (!data.id || !data.name || typeof data.description !== "string" || !data.category) {
+      throw new Error("createPrompt requires id, name, description, and category");
+    }
+    if (!PROMPT_ID_PATTERN.test(data.id)) {
+      throw new Error("Prompt ID must be a valid slug (lowercase, numbers, hyphens only)");
+    }
+    const existing = this.getPrompt(data.id);
+    if (existing) {
+      throw new Error(`Prompt with ID "${data.id}" already exists`);
+    }
+    const promptDirBase = data.status === "archived" ? this.archivedDir : this.activeDir;
+    const promptDir = path.join(promptDirBase, data.id);
+    if (!fs.existsSync(promptDir)) {
+      fs.mkdirSync(promptDir, { recursive: true });
+    }
+    const stmt = this.db.prepare(`
+      INSERT INTO prompts (
+        id, name, description, category, status, variant, tags,
+        auto_opt_in, current_version, created_at, updated_at, archived_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      data.id,
+      data.name,
+      data.description,
+      data.category,
+      data.status,
+      data.variant || null,
+      JSON.stringify(data.tags),
+      data.autoOptimize ? 1 : 0,
+      data.currentVersion,
+      now,
+      now,
+      data.status === "archived" ? now : null
+    );
+    return this.getPrompt(data.id);
+  }
+  /**
+   * Get a prompt by ID
+   */
+  getPrompt(id) {
+    const stmt = this.db.prepare("SELECT * FROM prompts WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPrompt(row);
+  }
+  /**
+   * Update a prompt
+   */
+  updatePrompt(id, updates) {
+    const existing = this.getPrompt(id);
+    if (!existing) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+      if (updates.status !== void 0 && updates.status !== "archived" && updates.status !== "active") {
+      }
+      if (updates.status === "archived" && existing.status !== "archived") {
+        setClauses.push("archived_at = ?");
+        values.push(now);
+      } else if (updates.status !== "archived" && existing.status === "archived") {
+        setClauses.push("archived_at = ?");
+        values.push(null);
+      }
+    }
+    if (updates.variant !== void 0) {
+      setClauses.push("variant = ?");
+      values.push(updates.variant || null);
+    }
+    if (updates.category !== void 0) {
+      setClauses.push("category = ?");
+      values.push(updates.category);
+    }
+    if (updates.tags !== void 0) {
+      setClauses.push("tags = ?");
+      values.push(JSON.stringify(updates.tags));
+    }
+    if (updates.autoOptimize !== void 0) {
+      setClauses.push("auto_opt_in = ?");
+      values.push(updates.autoOptimize ? 1 : 0);
+    }
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+    const stmt = this.db.prepare(`
+      UPDATE prompts
+      SET ${setClauses.join(", ")}
+      WHERE id = ?
+    `);
+    stmt.run(...values);
+    if (updates.status !== void 0) {
+      try {
+        if (updates.status === "archived" && existing.status !== "archived") {
+          this.movePromptFiles(id, "active", "archived");
+        } else if (updates.status !== "archived" && existing.status === "archived") {
+          this.movePromptFiles(id, "archived", "active");
+        }
+      } catch (moveErr) {
+        try {
+          const revertStmt = this.db.prepare(
+            "UPDATE prompts SET status = ?, archived_at = ?, updated_at = ? WHERE id = ?"
+          );
+          revertStmt.run(
+            existing.status,
+            existing.status === "archived" ? existing.archivedAt ?? now : null,
+            now,
+            id
+          );
+        } catch {
+        }
+        throw moveErr;
+      }
+    }
+    return this.getPrompt(id);
+  }
+  /**
+   * Delete a prompt and all its versions
+   */
+  deletePrompt(id) {
+    const prompt = this.getPrompt(id);
+    if (!prompt) {
+      return false;
+    }
+    try {
+      const versions = this.listVersions(id);
+      const stmt = this.db.prepare("DELETE FROM prompts WHERE id = ?");
+      const result = stmt.run(id);
+      for (const version of versions) {
+        const contentPath = this.getVersionContentPath(id, version.id, prompt.status);
+        if (fs.existsSync(contentPath)) {
+          fs.unlinkSync(contentPath);
+        }
+      }
+      return result.changes > 0;
+    } catch (error) {
+      console.error(`Error deleting prompt ${id}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * List prompts with optional filtering and pagination
+   */
+  listPrompts(criteria = {}) {
+    let query = "SELECT * FROM prompts WHERE 1=1";
+    const params = [];
+    if (criteria.category) {
+      query += " AND category = ?";
+      params.push(criteria.category);
+    }
+    if (criteria.status) {
+      query += " AND status = ?";
+      params.push(criteria.status);
+    }
+    if (criteria.variant) {
+      query += " AND variant = ?";
+      params.push(criteria.variant);
+    }
+    if (criteria.minUsageCount !== void 0) {
+      query += " AND usage_count >= ?";
+      params.push(criteria.minUsageCount);
+    }
+    if (criteria.tags && criteria.tags.length > 0) {
+      const normalizedTags = criteria.tags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter((tag) => tag.length > 0);
+      normalizedTags.forEach((tag) => {
+        query += " AND tags LIKE ? ESCAPE '\\'";
+        params.push(`%"${escapeLikePattern(tag)}"%`);
+      });
+    }
+    if (criteria.autoOptimize !== void 0) {
+      query += " AND auto_opt_in = ?";
+      params.push(criteria.autoOptimize ? 1 : 0);
+    }
+    if (criteria.query) {
+      query += " AND (name LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\')";
+      const searchPattern = `%${escapeLikePattern(criteria.query)}%`;
+      params.push(searchPattern, searchPattern);
+    }
+    const sortBy = criteria.sortBy || "updatedAt";
+    const sortOrder = (criteria.sortOrder || "desc").toLowerCase();
+    const sortColumn = {
+      name: "name",
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      usageCount: "usage_count",
+      successRate: "usage_count",
+      avgCompleteness: "usage_count"
+    }[sortBy] || "updated_at";
+    const sortDirection = sortOrder === "asc" ? "ASC" : "DESC";
+    query += ` ORDER BY ${sortColumn} ${sortDirection}`;
+    if (sortColumn !== "updated_at") {
+      query += ", updated_at DESC";
+    }
+    query += `, id ${sortDirection}`;
+    const hasLimit = typeof criteria.limit === "number";
+    const hasOffset = typeof criteria.offset === "number";
+    if (hasLimit) {
+      query += " LIMIT ?";
+      params.push(criteria.limit);
+    }
+    if (!hasLimit && hasOffset) {
+      query += " LIMIT -1";
+    }
+    if (hasOffset) {
+      query += " OFFSET ?";
+      params.push(criteria.offset);
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToPrompt(row));
+  }
+  createVersion(inputOrPromptId, versionId, content, options = {}) {
+    const data = typeof inputOrPromptId === "object" ? {
+      promptId: inputOrPromptId.promptId,
+      versionId: inputOrPromptId.id,
+      content: inputOrPromptId.content,
+      changelog: inputOrPromptId.changelog,
+      author: inputOrPromptId.author,
+      isGenerated: inputOrPromptId.isGenerated,
+      generationModel: inputOrPromptId.generationModel,
+      generationPrompt: inputOrPromptId.generationPrompt,
+      activate: inputOrPromptId.activate ?? inputOrPromptId.isActive ?? false
+    } : {
+      promptId: inputOrPromptId,
+      versionId: versionId ?? "",
+      content: content ?? "",
+      changelog: options.changelog,
+      author: options.author,
+      isGenerated: options.isGenerated,
+      generationModel: options.generationModel,
+      generationPrompt: options.generationPrompt,
+      activate: options.activate ?? false
+    };
+    if (!data.promptId || !data.versionId || data.content === void 0) {
+      throw new Error("createVersion requires promptId, versionId, and content");
+    }
+    const prompt = this.getPrompt(data.promptId);
+    if (!prompt) {
+      throw new Error(`Prompt with ID "${data.promptId}" not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const contentHash = this.hashContent(data.content);
+    const duplicateStmt = this.db.prepare(
+      "SELECT id FROM prompt_versions WHERE prompt_id = ? AND content_hash = ?"
+    );
+    const duplicate = duplicateStmt.get(data.promptId, contentHash);
+    if (duplicate) {
+      throw new Error("A version with identical content already exists");
+    }
+    if (!this.db.transaction) {
+      throw new Error("Database transaction not available");
+    }
+    const transaction = this.db.transaction(() => {
+      const versionColumns = [
+        "id",
+        "prompt_id",
+        "content_hash",
+        "changelog",
+        "author",
+        "is_active",
+        "is_generated",
+        "generation_model",
+        "generation_prompt",
+        "created_at",
+        "activated_at"
+      ];
+      const versionValues = [
+        data.versionId,
+        data.promptId,
+        contentHash,
+        data.changelog || null,
+        data.author || null,
+        0,
+        data.isGenerated ? 1 : 0,
+        data.generationModel || null,
+        data.generationPrompt || null,
+        now,
+        null
+      ];
+      if (this.promptVersionsHasColumn("version_number")) {
+        versionColumns.splice(2, 0, "version_number");
+        versionValues.splice(2, 0, this.nextLegacyVersionNumber(data.promptId));
+      }
+      if (this.promptVersionsHasColumn("content")) {
+        versionColumns.push("content");
+        versionValues.push(data.content);
+      }
+      if (this.promptVersionsHasColumn("created_by")) {
+        versionColumns.push("created_by");
+        versionValues.push(data.author || "unknown");
+      }
+      const placeholders = versionColumns.map(() => "?").join(", ");
+      const stmt = this.db.prepare(`
+        INSERT INTO prompt_versions (${versionColumns.join(", ")})
+        VALUES (${placeholders})
+      `);
+      stmt.run(...versionValues);
+      try {
+        this.saveVersionContent(data.promptId, data.versionId, data.content, prompt.status);
+        if (data.activate) {
+          performActivation(this.db, {
+            promptId: data.promptId,
+            versionId: data.versionId,
+            now
+          });
+        }
+      } catch (error) {
+        try {
+          this.deleteVersionContent(data.promptId, data.versionId, prompt.status);
+        } catch {
+        }
+        throw error;
+      }
+    });
+    transaction();
+    return this.getVersion(data.promptId, data.versionId);
+  }
+  getVersion(idOrPromptId, versionId) {
+    if (typeof versionId === "string") {
+      const stmt2 = this.db.prepare("SELECT * FROM prompt_versions WHERE prompt_id = ? AND id = ?");
+      const row = stmt2.get(idOrPromptId, versionId);
+      if (!row) return null;
+      return this.rowToVersion(row);
+    }
+    const stmt = this.db.prepare("SELECT * FROM prompt_versions WHERE id = ?");
+    const rows = stmt.all(idOrPromptId);
+    if (rows.length === 0) return null;
+    if (rows.length > 1) {
+      throw new Error(
+        `Version ID "${idOrPromptId}" is ambiguous (matches ${rows.length} prompts); pass promptId explicitly`
+      );
+    }
+    return this.rowToVersion(rows[0]);
+  }
+  /**
+   * Get active version for a prompt
+   */
+  getActiveVersion(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+    );
+    const row = stmt.get(promptId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToVersion(row);
+  }
+  /**
+   * List all versions for a prompt
+   */
+  listVersions(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY created_at DESC"
+    );
+    const rows = stmt.all(promptId);
+    return rows.map((row) => this.rowToVersion(row));
+  }
+  /** List versions, newest first, without reading any version's content. */
+  listVersionMetadata(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY created_at DESC"
+    );
+    return stmt.all(promptId).map((row) => this.rowToVersionMetadata(row));
+  }
+  /**
+   * Activate a version
+   */
+  activateVersion(promptId, versionId, reason) {
+    const version = this.getVersion(promptId, versionId);
+    if (!version) {
+      throw new Error(`Version "${versionId}" not found for prompt "${promptId}"`);
+    }
+    if (!this.db.transaction) {
+      throw new Error("Database transaction not available");
+    }
+    performActivation(this.db, { promptId, versionId });
+    this.recordActivationHistory(promptId, versionId, reason || "manual:activate");
+  }
+  /**
+   * Sync helper that writes one row into activation_history. Best-effort:
+   * the primary activation has already been performed by the caller, so a
+   * history-write failure must not abort it. Failures are surfaced via a
+   * console warning so test runs and ops surfaces still see them.
+   */
+  recordActivationHistory(promptId, versionId, reason) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const recordId = `activation-${promptId}-${versionId}-${Date.now()}`;
+      const stmt = this.db.prepare(`
+        INSERT INTO activation_history (
+          id, prompt_id, version_id, activated_at, activated_by, reason
+        )
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(recordId, promptId, versionId, now, "system:version-activation", reason);
+    } catch (error) {
+      console.warn(
+        `[prompts] activation_history insert failed for ${promptId}/${versionId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get performance metrics for a version
+   */
+  getPerformanceMetrics(versionId, variant) {
+    let query = "SELECT * FROM prompt_performance WHERE version_id = ?";
+    const params = [versionId];
+    if (variant) {
+      query += " AND variant = ?";
+      params.push(variant);
+    }
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(...params);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPerformance(row);
+  }
+  /**
+   * Get version content from its side file, falling back to the legacy inline column
+   */
+  getVersionContent(promptId, versionId, status = "active") {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    if (!fs.existsSync(contentPath)) {
+      const inline = readInlineVersionContent(this.db, promptId, versionId);
+      if (inline !== void 0) return inline;
+      throw new Error(`Content file not found for version ${versionId}`);
+    }
+    return fs.readFileSync(contentPath, "utf8");
+  }
+  /** Version ids in creation order; display numbers (`v1`, `v2`) derive from it. */
+  listVersionOrder(promptId) {
+    return readVersionOrder(this.db, promptId);
+  }
+  /**
+   * Creates a new version of an existing prompt with content
+   *
+   * Tracks parent version for lineage and validates prompt exists.
+   *
+   * @param promptId - ID of the prompt to version
+   * @param content - New version content
+   * @param options - Optional metadata (changelog, author, activation reason)
+   * @returns New version ID
+   * @throws Error if prompt not found
+   *
+   * @example
+   * const versionId = await store.createVersionAsync('user-auth', 'New prompt text', {
+   *   changelog: 'Improved clarity',
+   *   author: 'user:alice',
+   *   reason: 'Manual refinement'
+   * });
+   */
+  createVersionAsync(promptId, content, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const prompt = this.getPrompt(promptId);
+        if (!prompt) {
+          reject(new Error(`Prompt with ID "${promptId}" not found`));
+          return;
+        }
+        const versionId = crypto.randomBytes(8).toString("hex");
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const contentHash = this.hashContent(content);
+        const duplicateStmt = this.db.prepare(
+          "SELECT id FROM prompt_versions WHERE prompt_id = ? AND content_hash = ?"
+        );
+        const duplicate = duplicateStmt.get(promptId, contentHash);
+        if (duplicate) {
+          reject(new Error("A version with identical content already exists"));
+          return;
+        }
+        const currentActiveStmt = this.db.prepare(
+          "SELECT id FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+        );
+        const currentActive = currentActiveStmt.get(promptId);
+        const parentVersionId = currentActive?.id || null;
+        this.saveVersionContent(promptId, versionId, content, prompt.status);
+        const versionColumns = [
+          "id",
+          "prompt_id",
+          "content_hash",
+          "changelog",
+          "author",
+          "is_active",
+          "is_generated",
+          "generation_model",
+          "generation_prompt",
+          "created_at",
+          "parent_version_id"
+        ];
+        const versionValues = [
+          versionId,
+          promptId,
+          contentHash,
+          options?.changelog || null,
+          options?.author || null,
+          0,
+          // not active by default
+          options?.isGenerated ? 1 : 0,
+          options?.generationModel || null,
+          options?.generationPrompt || null,
+          now,
+          parentVersionId
+        ];
+        if (this.promptVersionsHasColumn("version_number")) {
+          versionColumns.splice(2, 0, "version_number");
+          versionValues.splice(2, 0, this.nextLegacyVersionNumber(promptId));
+        }
+        if (this.promptVersionsHasColumn("content")) {
+          versionColumns.push("content");
+          versionValues.push(content);
+        }
+        if (this.promptVersionsHasColumn("created_by")) {
+          versionColumns.push("created_by");
+          versionValues.push(options?.author || "unknown");
+        }
+        const placeholders = versionColumns.map(() => "?").join(", ");
+        const stmt = this.db.prepare(`
+          INSERT INTO prompt_versions (${versionColumns.join(", ")})
+          VALUES (${placeholders})
+        `);
+        stmt.run(...versionValues);
+        resolve(versionId);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  // Private helper methods
+  rowToPrompt(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      category: row.category,
+      status: row.status,
+      variant: row.variant ?? void 0,
+      tags: parseJsonWithContext(row.tags, "PromptStore.tags") ?? [],
+      autoOptimize: row.auto_opt_in === 1,
+      currentVersion: row.current_version || row.active_version_id || "",
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      archivedAt: row.archived_at || void 0,
+      usageCount: row.usage_count,
+      lastUsedAt: row.last_used_at || void 0
+    };
+  }
+  rowToVersion(row) {
+    const prompt = this.getPrompt(row.prompt_id);
+    if (!prompt) {
+      throw new Error(`Prompt "${row.prompt_id}" not found while resolving version "${row.id}"`);
+    }
+    const content = this.getVersionContent(row.prompt_id, row.id, prompt.status);
+    return { ...this.rowToVersionMetadata(row), content };
+  }
+  rowToVersionMetadata(row) {
+    return {
+      id: row.id,
+      promptId: row.prompt_id,
+      contentHash: row.content_hash,
+      changelog: row.changelog || void 0,
+      author: row.author || row.created_by || void 0,
+      isActive: row.is_active === 1,
+      isGenerated: row.is_generated === 1,
+      generationModel: row.generation_model || void 0,
+      generationPrompt: row.generation_prompt || void 0,
+      parentVersionId: row.parent_version_id || void 0,
+      createdAt: row.created_at,
+      activatedAt: row.activated_at || void 0,
+      deactivatedAt: row.deactivated_at || void 0
+    };
+  }
+  rowToPerformance(row) {
+    return {
+      promptId: row.prompt_id,
+      versionId: row.version_id,
+      variant: row.variant ?? null,
+      totalExecutions: row.total_executions,
+      successfulExecutions: row.successful_executions,
+      failedExecutions: row.failed_executions,
+      successRate: row.success_rate,
+      avgCompleteness: row.avg_completeness,
+      avgCodeDeliveryRate: row.avg_code_delivery_rate,
+      avgDuration: row.avg_duration,
+      minCompleteness: row.min_completeness,
+      maxCompleteness: row.max_completeness,
+      stdDevCompleteness: row.std_dev_completeness,
+      sampleSize: row.sample_size,
+      firstExecutionAt: row.first_execution_at,
+      lastExecutionAt: row.last_execution_at,
+      calculatedAt: row.calculated_at
+    };
+  }
+  /** The content hash the store keys duplicate-content checks on. */
+  hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  saveVersionContent(promptId, versionId, content, status) {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    atomicWriteTextSync(contentPath, content);
+  }
+  deleteVersionContent(promptId, versionId, status) {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    try {
+      fs.unlinkSync(contentPath);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  movePromptFiles(id, from, to) {
+    const fromDir = from === "archived" ? this.archivedDir : this.activeDir;
+    const toDir = to === "archived" ? this.archivedDir : this.activeDir;
+    this.ensureSafePromptId(id);
+    const versionRows = this.db.prepare("SELECT id FROM prompt_versions WHERE prompt_id = ?").all(id);
+    for (const row of versionRows) {
+      this.ensureSafeVersionId(row.id);
+      const srcPath = path.join(fromDir, `${id}-${row.id}.txt`);
+      const destPath = path.join(toDir, `${id}-${row.id}.txt`);
+      if (fs.existsSync(srcPath)) {
+        fs.renameSync(srcPath, destPath);
+      }
+    }
+  }
+  ensureSafePromptId(promptId) {
+    assertSafePromptId(promptId);
+  }
+  ensureSafeVersionId(versionId) {
+    assertSafeVersionId(versionId);
+  }
+  getVersionContentPath(promptId, versionId, status = "active") {
+    this.ensureSafePromptId(promptId);
+    this.ensureSafeVersionId(versionId);
+    const baseDir = status === "archived" ? this.archivedDir : this.activeDir;
+    return path.join(baseDir, `${promptId}-${versionId}.txt`);
+  }
+};
+
+export {
+  PROMPT_VERSION_INDEXES_SQL,
+  readInlineVersionContent,
+  assertSafePromptId,
+  assertSafeVersionId,
+  PromptStore
+};
+//# sourceMappingURL=chunk-GAB6UW52.js.map