@hyperfixi/patterns-reference 2.0.0

package/dist/index.js

@@ -0,0 +1,1312 @@
+'use strict';
+
+var Database = require('better-sqlite3');
+var url = require('url');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var __filename2 = url.fileURLToPath(importMetaUrl);
+var __dirname$1 = path.dirname(__filename2);
+var DEFAULT_DB_PATH = process.env.LSP_DB_PATH || process.env.HYPERSCRIPT_LSP_DB || path.join(__dirname$1, "../data/patterns.db");
+var dbInstance = null;
+var currentDbPath = null;
+function getDatabase(options = {}) {
+  const dbPath = options.dbPath ?? DEFAULT_DB_PATH;
+  if (dbInstance !== null && currentDbPath === dbPath) {
+    return dbInstance;
+  }
+  if (dbInstance !== null) {
+    dbInstance.close();
+  }
+  dbInstance = new Database__default.default(dbPath, {
+    readonly: options.readonly ?? false
+  });
+  dbInstance.pragma("foreign_keys = ON");
+  currentDbPath = dbPath;
+  return dbInstance;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+    currentDbPath = null;
+  }
+}
+function resetConnection() {
+  dbInstance = null;
+  currentDbPath = null;
+}
+function isConnected() {
+  return dbInstance !== null;
+}
+function getCurrentDbPath() {
+  return currentDbPath;
+}
+
+// src/api/patterns.ts
+async function getPatternById(id, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare(
+    `
+    SELECT id, title, raw_code, description, feature, engine, created_at
+    FROM code_examples
+    WHERE id = ?
+  `
+  ).get(id);
+  return row ? mapRowToPattern(row) : null;
+}
+async function getPatternsByCategory(category, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT id, title, raw_code, description, feature, engine, created_at
+    FROM code_examples
+    WHERE feature = ?
+    ORDER BY title
+  `
+  ).all(category);
+  return rows.map(mapRowToPattern);
+}
+async function getPatternsByCommand(command, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT id, title, raw_code, description, feature, engine, created_at
+    FROM code_examples
+    WHERE raw_code LIKE ?
+    ORDER BY title
+  `
+  ).all(`%${command}%`);
+  return rows.filter((row) => new RegExp(`\\b${command}\\b`, "i").test(row.raw_code)).map(mapRowToPattern);
+}
+async function searchPatterns(query, searchOptions = {}, connOptions) {
+  const db = getDatabase({ ...connOptions, readonly: true });
+  const { limit = 50, offset = 0 } = searchOptions;
+  const rows = db.prepare(
+    `
+    SELECT id, title, raw_code, description, feature, engine, created_at
+    FROM code_examples
+    WHERE title LIKE ? OR raw_code LIKE ? OR description LIKE ?
+    ORDER BY title
+    LIMIT ? OFFSET ?
+  `
+  ).all(`%${query}%`, `%${query}%`, `%${query}%`, limit, offset);
+  return rows.map(mapRowToPattern);
+}
+async function getAllPatterns(searchOptions = {}, connOptions) {
+  const db = getDatabase({ ...connOptions, readonly: true });
+  const { limit = 1e3, offset = 0 } = searchOptions;
+  const rows = db.prepare(
+    `
+    SELECT id, title, raw_code, description, feature, engine, created_at
+    FROM code_examples
+    ORDER BY title
+    LIMIT ? OFFSET ?
+  `
+  ).all(limit, offset);
+  return rows.map(mapRowToPattern);
+}
+async function getPatternStats(connOptions) {
+  const db = getDatabase({ ...connOptions, readonly: true });
+  const patternCount = db.prepare("SELECT COUNT(*) as count FROM code_examples").get();
+  const translationCount = db.prepare("SELECT COUNT(*) as count FROM pattern_translations").get();
+  const byLangRows = db.prepare(
+    `
+    SELECT
+      language,
+      COUNT(*) as count,
+      SUM(verified_parses) as verified_count
+    FROM pattern_translations
+    GROUP BY language
+  `
+  ).all();
+  const byLanguage = {};
+  for (const row of byLangRows) {
+    byLanguage[row.language] = {
+      count: row.count,
+      verifiedCount: row.verified_count
+    };
+  }
+  const byCatRows = db.prepare(
+    `
+    SELECT feature, COUNT(*) as count
+    FROM code_examples
+    WHERE feature IS NOT NULL
+    GROUP BY feature
+  `
+  ).all();
+  const byCategory = {};
+  for (const row of byCatRows) {
+    byCategory[row.feature] = row.count;
+  }
+  const avgConfResult = db.prepare("SELECT AVG(confidence) as avg FROM pattern_translations WHERE confidence > 0").get();
+  return {
+    totalPatterns: patternCount.count,
+    totalTranslations: translationCount.count,
+    byLanguage,
+    byCategory,
+    avgConfidence: avgConfResult.avg || 0
+  };
+}
+function mapRowToPattern(row) {
+  return {
+    id: row.id,
+    title: row.title,
+    description: row.description,
+    rawCode: row.raw_code,
+    category: row.feature,
+    primaryCommand: extractPrimaryCommand(row.raw_code),
+    tags: extractTags(row.raw_code),
+    difficulty: inferDifficulty(row.raw_code),
+    engine: row.engine || null,
+    createdAt: new Date(row.created_at)
+  };
+}
+function extractPrimaryCommand(code) {
+  const match = code.match(/^(on|toggle|put|set|add|remove|show|hide|wait|log|send|fetch|call)\b/i);
+  return match ? match[1].toLowerCase() : null;
+}
+function extractTags(code) {
+  const tags = [];
+  if (code.includes(".")) tags.push("class");
+  if (code.includes("#")) tags.push("id");
+  if (code.includes("on ")) tags.push("event");
+  if (code.includes("fetch")) tags.push("async");
+  if (code.includes("wait")) tags.push("timing");
+  return tags;
+}
+function inferDifficulty(code) {
+  const lines = code.split("\n").filter((l) => l.trim()).length;
+  if (lines === 1 && !code.includes("then")) return "beginner";
+  if (lines <= 3) return "intermediate";
+  return "advanced";
+}
+
+// src/api/translations.ts
+async function getTranslation(patternId, language, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare(
+    `
+    SELECT * FROM pattern_translations
+    WHERE code_example_id = ? AND language = ?
+  `
+  ).get(patternId, language);
+  return row ? mapRowToTranslation(row) : null;
+}
+async function getAllTranslations(patternId, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM pattern_translations
+    WHERE code_example_id = ?
+    ORDER BY language
+  `
+  ).all(patternId);
+  return rows.map(mapRowToTranslation);
+}
+async function getTranslationsByLanguage(language, limit = 100, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM pattern_translations
+    WHERE language = ?
+    ORDER BY confidence DESC
+    LIMIT ?
+  `
+  ).all(language, limit);
+  return rows.map(mapRowToTranslation);
+}
+async function getVerifiedTranslations(language, limit = 100, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM pattern_translations
+    WHERE language = ? AND verified_parses = 1
+    ORDER BY confidence DESC
+    LIMIT ?
+  `
+  ).all(language, limit);
+  return rows.map(mapRowToTranslation);
+}
+async function getHighConfidenceTranslations(minConfidence = 0.8, limit = 100, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM pattern_translations
+    WHERE confidence >= ? AND verified_parses = 1
+    ORDER BY confidence DESC
+    LIMIT ?
+  `
+  ).all(minConfidence, limit);
+  return rows.map(mapRowToTranslation);
+}
+async function verifyTranslation(translation, options) {
+  let parseSuccess = false;
+  let errorMessage = null;
+  let confidence = translation.confidence;
+  try {
+    const { canParse, parse } = await import('@lokascript/semantic');
+    if (canParse(translation.hyperscript, translation.language)) {
+      parse(translation.hyperscript, translation.language);
+      parseSuccess = true;
+    } else {
+      errorMessage = "canParse returned false";
+    }
+  } catch (e) {
+    errorMessage = e.message;
+  }
+  const db = getDatabase(options);
+  db.prepare(
+    `
+    UPDATE pattern_translations
+    SET verified_parses = ?, updated_at = datetime('now')
+    WHERE id = ?
+  `
+  ).run(parseSuccess ? 1 : 0, translation.id);
+  db.prepare(
+    `
+    INSERT INTO pattern_tests
+      (code_example_id, language, test_date, parse_success, error_message)
+    VALUES (?, ?, datetime('now'), ?, ?)
+  `
+  ).run(translation.codeExampleId, translation.language, parseSuccess ? 1 : 0, errorMessage);
+  return {
+    translation,
+    parseSuccess,
+    executeSuccess: false,
+    // Not implemented yet
+    errorMessage,
+    confidence,
+    testedAt: /* @__PURE__ */ new Date()
+  };
+}
+async function getTranslationStats(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT
+      language,
+      COUNT(*) as total,
+      SUM(verified_parses) as verified,
+      AVG(confidence) as avg_confidence
+    FROM pattern_translations
+    GROUP BY language
+  `
+  ).all();
+  const stats = {};
+  for (const row of rows) {
+    stats[row.language] = {
+      total: row.total,
+      verified: row.verified,
+      avgConfidence: row.avg_confidence || 0
+    };
+  }
+  return stats;
+}
+function mapRowToTranslation(row) {
+  return {
+    id: row.id,
+    codeExampleId: row.code_example_id,
+    language: row.language,
+    hyperscript: row.hyperscript,
+    wordOrder: row.word_order,
+    translationMethod: row.translation_method,
+    confidence: row.confidence,
+    verifiedParses: row.verified_parses === 1,
+    verifiedExecutes: row.verified_executes === 1,
+    roleAlignmentScore: row.role_alignment_score ?? null,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function getWordOrder(language) {
+  const wordOrders = {
+    en: "SVO",
+    es: "SVO",
+    fr: "SVO",
+    pt: "SVO",
+    id: "SVO",
+    sw: "SVO",
+    zh: "SVO",
+    ja: "SOV",
+    ko: "SOV",
+    tr: "SOV",
+    qu: "SOV",
+    ar: "VSO",
+    de: "V2"
+  };
+  return wordOrders[language] || "SVO";
+}
+
+// src/api/llm.ts
+async function getLLMExamples(prompt, language = "en", limit = 5, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const keywords = extractKeywords(prompt);
+  if (keywords.length === 0) {
+    const rows2 = db.prepare(
+      `
+      SELECT * FROM llm_examples
+      WHERE language = ?
+      ORDER BY quality_score DESC, usage_count DESC
+      LIMIT ?
+    `
+    ).all(language, limit);
+    trackUsage(
+      db,
+      rows2.map((r) => r.id)
+    );
+    return rows2.map(mapRowToLLMExample);
+  }
+  const likeClauses = keywords.map(() => "(prompt LIKE ? OR completion LIKE ?)").join(" OR ");
+  const params = keywords.flatMap((k) => [`%${k}%`, `%${k}%`]);
+  const rows = db.prepare(
+    `
+    SELECT * FROM llm_examples
+    WHERE language = ? AND (${likeClauses})
+    ORDER BY quality_score DESC
+    LIMIT ?
+  `
+  ).all(language, ...params, limit);
+  trackUsage(
+    db,
+    rows.map((r) => r.id)
+  );
+  return rows.map(mapRowToLLMExample);
+}
+async function getExamplesByCommand(command, language = "en", limit = 5, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM llm_examples
+    WHERE language = ? AND completion LIKE ?
+    ORDER BY quality_score DESC
+    LIMIT ?
+  `
+  ).all(language, `%${command}%`, limit);
+  return rows.map(mapRowToLLMExample);
+}
+async function getHighQualityExamples(language = "en", minQuality = 0.8, limit = 10, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM llm_examples
+    WHERE language = ? AND quality_score >= ?
+    ORDER BY quality_score DESC, usage_count DESC
+    LIMIT ?
+  `
+  ).all(language, minQuality, limit);
+  return rows.map(mapRowToLLMExample);
+}
+async function getMostUsedExamples(language = "en", limit = 10, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare(
+    `
+    SELECT * FROM llm_examples
+    WHERE language = ?
+    ORDER BY usage_count DESC, quality_score DESC
+    LIMIT ?
+  `
+  ).all(language, limit);
+  return rows.map(mapRowToLLMExample);
+}
+async function buildFewShotContext(prompt, language = "en", numExamples = 3, options) {
+  const examples = await getLLMExamples(prompt, language, numExamples, options);
+  if (examples.length === 0) {
+    return "";
+  }
+  let context = "Here are some example hyperscript patterns:\n\n";
+  for (const ex of examples) {
+    context += `Task: ${ex.prompt}
+`;
+    context += `Code: ${ex.completion}
+
+`;
+  }
+  context += `Now generate hyperscript for: ${prompt}
+`;
+  return context;
+}
+async function addLLMExample(example, options) {
+  const db = getDatabase(options);
+  const result = db.prepare(
+    `
+    INSERT INTO llm_examples
+      (code_example_id, language, prompt, completion, quality_score, usage_count, created_at)
+    VALUES (?, ?, ?, ?, ?, 0, datetime('now'))
+  `
+  ).run(
+    example.patternId,
+    example.language,
+    example.prompt,
+    example.completion,
+    example.qualityScore
+  );
+  return result.lastInsertRowid;
+}
+async function updateQualityScore(id, qualityScore, options) {
+  const db = getDatabase(options);
+  db.prepare(
+    `
+    UPDATE llm_examples SET quality_score = ? WHERE id = ?
+  `
+  ).run(qualityScore, id);
+}
+async function getLLMStats(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const totalResult = db.prepare("SELECT COUNT(*) as count FROM llm_examples").get();
+  const byLangResult = db.prepare(
+    `
+    SELECT language, COUNT(*) as count
+    FROM llm_examples
+    GROUP BY language
+  `
+  ).all();
+  const avgResult = db.prepare("SELECT AVG(quality_score) as avg FROM llm_examples").get();
+  const usageResult = db.prepare("SELECT SUM(usage_count) as total FROM llm_examples").get();
+  const byLanguage = {};
+  for (const { language, count } of byLangResult) {
+    byLanguage[language] = count;
+  }
+  return {
+    total: totalResult.count,
+    byLanguage,
+    avgQuality: avgResult.avg || 0,
+    totalUsage: usageResult.total || 0
+  };
+}
+function extractKeywords(prompt) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "to",
+    "on",
+    "in",
+    "for",
+    "is",
+    "it",
+    "when",
+    "i",
+    "want",
+    "need",
+    "create",
+    "make",
+    "please",
+    "can",
+    "you",
+    "would",
+    "should",
+    "like",
+    "that",
+    "this",
+    "with",
+    "from"
+  ]);
+  return prompt.toLowerCase().split(/\W+/).filter((word) => word.length > 2 && !stopWords.has(word));
+}
+function trackUsage(db, ids) {
+  if (ids.length === 0) return;
+  try {
+    const stmt = db.prepare(`
+      UPDATE llm_examples SET usage_count = usage_count + 1 WHERE id = ?
+    `);
+    for (const id of ids) {
+      stmt.run(id);
+    }
+  } catch {
+  }
+}
+function mapRowToLLMExample(row) {
+  return {
+    id: row.id,
+    patternId: row.code_example_id,
+    language: row.language,
+    prompt: row.prompt,
+    completion: row.completion,
+    qualityScore: row.quality_score,
+    usageCount: row.usage_count,
+    createdAt: new Date(row.created_at)
+  };
+}
+
+// src/api/language-docs.ts
+function mapCommand(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    syntax: row.syntax,
+    purpose: row.purpose,
+    implicitTarget: row.implicit_target,
+    implicitResultTarget: row.implicit_result_target,
+    isBlocking: row.is_blocking === 1,
+    hasBody: row.has_body === 1,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function mapExpression(row, operators = []) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    category: row.category,
+    evaluatesToType: row.evaluates_to_type,
+    precedence: row.precedence,
+    associativity: row.associativity,
+    operators,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function mapKeyword(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    contextOfUse: row.context_of_use,
+    isOptional: row.is_optional === 1,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function mapFeature(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    syntax: row.syntax,
+    trigger: row.trigger,
+    structureDescription: row.structure_description,
+    scopeImpact: row.scope_impact,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function mapSpecialSymbol(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    symbol: row.symbol,
+    symbolType: row.symbol_type,
+    description: row.description,
+    typicalValue: row.typical_value,
+    scopeImplications: row.scope_implications,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+async function getCommandByName(name, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare("SELECT * FROM commands WHERE LOWER(name) = LOWER(?)").get(name);
+  return row ? mapCommand(row) : null;
+}
+async function getAllCommands(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM commands ORDER BY name").all();
+  return rows.map(mapCommand);
+}
+async function searchCommands(query, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const pattern = `%${query}%`;
+  const rows = db.prepare(
+    `SELECT * FROM commands
+       WHERE LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)
+       ORDER BY name`
+  ).all(pattern, pattern);
+  return rows.map(mapCommand);
+}
+async function getExpressionByName(name, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare("SELECT * FROM expressions WHERE LOWER(name) = LOWER(?)").get(name);
+  if (!row) return null;
+  const operators = db.prepare("SELECT operator FROM expression_operators WHERE expression_id = ?").all(row.id);
+  return mapExpression(
+    row,
+    operators.map((o) => o.operator)
+  );
+}
+async function getAllExpressions(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM expressions ORDER BY name").all();
+  const allOperators = db.prepare("SELECT expression_id, operator FROM expression_operators").all();
+  const operatorMap = /* @__PURE__ */ new Map();
+  for (const op of allOperators) {
+    const ops = operatorMap.get(op.expression_id) || [];
+    ops.push(op.operator);
+    operatorMap.set(op.expression_id, ops);
+  }
+  return rows.map((row) => mapExpression(row, operatorMap.get(row.id) || []));
+}
+async function getExpressionsByCategory(category, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM expressions WHERE LOWER(category) = LOWER(?) ORDER BY name").all(category);
+  const ids = rows.map((r) => r.id);
+  if (ids.length === 0) return [];
+  const placeholders = ids.map(() => "?").join(",");
+  const allOperators = db.prepare(
+    `SELECT expression_id, operator FROM expression_operators WHERE expression_id IN (${placeholders})`
+  ).all(...ids);
+  const operatorMap = /* @__PURE__ */ new Map();
+  for (const op of allOperators) {
+    const ops = operatorMap.get(op.expression_id) || [];
+    ops.push(op.operator);
+    operatorMap.set(op.expression_id, ops);
+  }
+  return rows.map((row) => mapExpression(row, operatorMap.get(row.id) || []));
+}
+async function getKeywordByName(name, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare("SELECT * FROM keywords WHERE LOWER(name) = LOWER(?)").get(name);
+  return row ? mapKeyword(row) : null;
+}
+async function getAllKeywords(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM keywords ORDER BY name").all();
+  return rows.map(mapKeyword);
+}
+async function getFeatureByName(name, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare("SELECT * FROM features WHERE LOWER(name) = LOWER(?)").get(name);
+  return row ? mapFeature(row) : null;
+}
+async function getAllFeatures(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM features ORDER BY name").all();
+  return rows.map(mapFeature);
+}
+async function getSpecialSymbolByName(name, options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const row = db.prepare(
+    "SELECT * FROM special_symbols WHERE LOWER(name) = LOWER(?) OR LOWER(symbol) = LOWER(?)"
+  ).get(name, name);
+  return row ? mapSpecialSymbol(row) : null;
+}
+async function getAllSpecialSymbols(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const rows = db.prepare("SELECT * FROM special_symbols ORDER BY name").all();
+  return rows.map(mapSpecialSymbol);
+}
+async function searchLanguageElements(query, types, options) {
+  const results = [];
+  const searchTypes = types || ["command", "expression", "keyword", "feature", "special_symbol"];
+  if (searchTypes.includes("command")) {
+    const commands = await searchCommands(query, options);
+    results.push(...commands.map((c) => ({ type: "command", element: c })));
+  }
+  if (searchTypes.includes("expression")) {
+    const db = getDatabase({ ...options, readonly: true });
+    const pattern = `%${query}%`;
+    const rows = db.prepare(
+      `SELECT * FROM expressions
+         WHERE LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?) OR LOWER(category) LIKE LOWER(?)
+         ORDER BY name`
+    ).all(pattern, pattern, pattern);
+    const ids = rows.map((r) => r.id);
+    const operatorMap = /* @__PURE__ */ new Map();
+    if (ids.length > 0) {
+      const placeholders = ids.map(() => "?").join(",");
+      const ops = db.prepare(
+        `SELECT expression_id, operator FROM expression_operators WHERE expression_id IN (${placeholders})`
+      ).all(...ids);
+      for (const op of ops) {
+        const arr = operatorMap.get(op.expression_id) || [];
+        arr.push(op.operator);
+        operatorMap.set(op.expression_id, arr);
+      }
+    }
+    results.push(
+      ...rows.map((row) => ({
+        type: "expression",
+        element: mapExpression(row, operatorMap.get(row.id) || [])
+      }))
+    );
+  }
+  if (searchTypes.includes("keyword")) {
+    const db = getDatabase({ ...options, readonly: true });
+    const pattern = `%${query}%`;
+    const rows = db.prepare(
+      `SELECT * FROM keywords
+         WHERE LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)
+         ORDER BY name`
+    ).all(pattern, pattern);
+    results.push(...rows.map((row) => ({ type: "keyword", element: mapKeyword(row) })));
+  }
+  if (searchTypes.includes("feature")) {
+    const db = getDatabase({ ...options, readonly: true });
+    const pattern = `%${query}%`;
+    const rows = db.prepare(
+      `SELECT * FROM features
+         WHERE LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)
+         ORDER BY name`
+    ).all(pattern, pattern);
+    results.push(...rows.map((row) => ({ type: "feature", element: mapFeature(row) })));
+  }
+  if (searchTypes.includes("special_symbol")) {
+    const db = getDatabase({ ...options, readonly: true });
+    const pattern = `%${query}%`;
+    const rows = db.prepare(
+      `SELECT * FROM special_symbols
+         WHERE LOWER(name) LIKE LOWER(?) OR LOWER(symbol) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)
+         ORDER BY name`
+    ).all(pattern, pattern, pattern);
+    results.push(
+      ...rows.map((row) => ({ type: "special_symbol", element: mapSpecialSymbol(row) }))
+    );
+  }
+  return results;
+}
+async function getLanguageDocsStats(options) {
+  const db = getDatabase({ ...options, readonly: true });
+  const getCount = (table) => {
+    try {
+      const result = db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+      return result.count;
+    } catch {
+      return 0;
+    }
+  };
+  return {
+    commands: getCount("commands"),
+    expressions: getCount("expressions"),
+    keywords: getCount("keywords"),
+    features: getCount("features"),
+    specialSymbols: getCount("special_symbols"),
+    expressionOperators: getCount("expression_operators")
+  };
+}
+
+// src/sync/index.ts
+async function syncTranslations(_options = {}) {
+  throw new Error(
+    "syncTranslations should be run via: bun run packages/semantic/scripts/sync-lsp-translations.ts"
+  );
+}
+async function validateAllTranslations(_options = {}) {
+  throw new Error(
+    "validateAllTranslations should be run via: bun run packages/semantic/scripts/validate-translations.ts"
+  );
+}
+async function discoverPatterns(_verbose = false) {
+  throw new Error(
+    "discoverPatterns should be run via: bun run packages/semantic/scripts/pattern-discovery.ts"
+  );
+}
+async function seedLLMExamples(_dryRun = false) {
+  throw new Error(
+    "seedLLMExamples should be run via: bun run packages/semantic/scripts/seed-llm-examples.ts"
+  );
+}
+
+// src/adapters/llm-adapter.ts
+var syncDatabaseAvailable = true;
+function isDatabaseAvailable() {
+  try {
+    getDatabase({ readonly: true });
+    return true;
+  } catch {
+    syncDatabaseAvailable = false;
+    return false;
+  }
+}
+function findRelevantExamples(prompt, language = "en", limit = 5) {
+  if (!syncDatabaseAvailable) return [];
+  try {
+    const db = getDatabase({ readonly: true });
+    const keywords = extractKeywords2(prompt);
+    if (keywords.length === 0) {
+      const rows2 = db.prepare(
+        `
+        SELECT id, prompt, completion, language, quality_score as qualityScore
+        FROM llm_examples
+        WHERE language = ?
+        ORDER BY quality_score DESC, usage_count DESC
+        LIMIT ?
+      `
+      ).all(language, limit);
+      trackUsageSync(
+        db,
+        rows2.map((r) => r.id)
+      );
+      return rows2;
+    }
+    const likeClauses = keywords.map(() => "(prompt LIKE ? OR completion LIKE ?)").join(" OR ");
+    const params = keywords.flatMap((k) => [`%${k}%`, `%${k}%`]);
+    const rows = db.prepare(
+      `
+      SELECT id, prompt, completion, language, quality_score as qualityScore
+      FROM llm_examples
+      WHERE language = ? AND (${likeClauses})
+      ORDER BY quality_score DESC
+      LIMIT ?
+    `
+    ).all(language, ...params, limit);
+    trackUsageSync(
+      db,
+      rows.map((r) => r.id)
+    );
+    return rows;
+  } catch (error) {
+    console.warn(
+      "[LLM Adapter] Query failed:",
+      error instanceof Error ? error.message : String(error)
+    );
+    syncDatabaseAvailable = false;
+    return [];
+  }
+}
+function findExamplesByCommand(command, language = "en", limit = 5) {
+  if (!syncDatabaseAvailable) return [];
+  try {
+    const db = getDatabase({ readonly: true });
+    const rows = db.prepare(
+      `
+      SELECT id, prompt, completion, language, quality_score as qualityScore
+      FROM llm_examples
+      WHERE language = ? AND completion LIKE ?
+      ORDER BY quality_score DESC
+      LIMIT ?
+    `
+    ).all(language, `%${command}%`, limit);
+    return rows;
+  } catch (error) {
+    console.warn(
+      "[LLM Adapter] Query failed:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return [];
+  }
+}
+function buildFewShotContextSync(prompt, language = "en", numExamples = 3) {
+  const examples = findRelevantExamples(prompt, language, numExamples);
+  if (examples.length === 0) {
+    return "";
+  }
+  let context = "Here are some example hyperscript patterns:\n\n";
+  for (const ex of examples) {
+    context += `Task: ${ex.prompt}
+`;
+    context += `Code: ${ex.completion}
+
+`;
+  }
+  context += `Now generate hyperscript for: ${prompt}
+`;
+  return context;
+}
+function trackExampleUsage(ids) {
+  if (!syncDatabaseAvailable || ids.length === 0) return;
+  try {
+    const db = getDatabase();
+    trackUsageSync(db, ids);
+  } catch {
+  }
+}
+function getLLMExampleStats() {
+  if (!syncDatabaseAvailable) return null;
+  try {
+    const db = getDatabase({ readonly: true });
+    const totalResult = db.prepare("SELECT COUNT(*) as count FROM llm_examples").get();
+    const byLangResult = db.prepare(
+      `
+      SELECT language, COUNT(*) as count
+      FROM llm_examples
+      GROUP BY language
+    `
+    ).all();
+    const avgResult = db.prepare("SELECT AVG(quality_score) as avg FROM llm_examples").get();
+    const byLanguage = {};
+    for (const { language, count } of byLangResult) {
+      byLanguage[language] = count;
+    }
+    return {
+      total: totalResult.count,
+      byLanguage,
+      avgQuality: avgResult.avg || 0
+    };
+  } catch {
+    return null;
+  }
+}
+function extractKeywords2(prompt) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "to",
+    "on",
+    "in",
+    "for",
+    "is",
+    "it",
+    "when",
+    "i",
+    "want",
+    "need",
+    "create",
+    "make",
+    "please",
+    "can",
+    "you",
+    "would",
+    "should",
+    "like",
+    "that",
+    "this",
+    "with",
+    "from"
+  ]);
+  return prompt.toLowerCase().split(/\W+/).filter((word) => word.length > 2 && !stopWords.has(word));
+}
+function trackUsageSync(db, ids) {
+  if (ids.length === 0) return;
+  try {
+    const stmt = db.prepare(`
+      UPDATE llm_examples SET usage_count = usage_count + 1 WHERE id = ?
+    `);
+    for (const id of ids) {
+      stmt.run(id);
+    }
+  } catch {
+  }
+}
+function createLLMAdapter(options) {
+  getDatabase(options);
+  return {
+    // Sync methods (backward compatibility with llm-examples-query.ts)
+    findRelevantExamples,
+    findExamplesByCommand,
+    buildFewShotContextSync,
+    trackExampleUsage,
+    getLLMExampleStats,
+    isDatabaseAvailable,
+    // Async methods (preferred for new code)
+    getLLMExamples: (prompt, language, limit) => getLLMExamples(prompt, language, limit, options),
+    getExamplesByCommand: (command, language, limit) => getExamplesByCommand(command, language, limit, options),
+    getHighQualityExamples: (language, minQuality, limit) => getHighQualityExamples(language, minQuality, limit, options),
+    getMostUsedExamples: (language, limit) => getMostUsedExamples(language, limit, options),
+    buildFewShotContext: (prompt, language, numExamples) => buildFewShotContext(prompt, language, numExamples, options),
+    getLLMStats: () => getLLMStats(options),
+    // Cleanup
+    close: closeDatabase
+  };
+}
+
+// src/registry/patterns-provider.ts
+var DatabasePatternsProvider = class {
+  id = "patterns-reference-db";
+  name = "Patterns Reference Database";
+  options;
+  languageCache = /* @__PURE__ */ new Map();
+  supportedLanguagesCache = null;
+  constructor(options) {
+    this.options = options || {};
+  }
+  /**
+   * Get patterns for a specific language.
+   */
+  async getPatternsForLanguage(language) {
+    const cached = this.languageCache.get(language);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const translations = await getVerifiedTranslations(language, 1e3, this.options);
+      const patterns = translations.map((t) => ({
+        id: t.codeExampleId,
+        code: t.hyperscript,
+        command: this.extractCommand(t.hyperscript),
+        language: t.language,
+        confidence: t.confidence,
+        verified: t.verifiedParses
+      }));
+      this.languageCache.set(language, patterns);
+      return patterns;
+    } catch (error) {
+      console.warn(
+        `[PatternsProvider] Failed to get patterns for ${language}:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      return [];
+    }
+  }
+  /**
+   * Get patterns for a specific command.
+   */
+  async getPatternsForCommand(command, language) {
+    try {
+      const patterns = await getPatternsByCommand(command, this.options);
+      const entries = patterns.map((p) => ({
+        id: p.id,
+        code: p.rawCode,
+        command: p.primaryCommand,
+        language: language || "en",
+        confidence: 1,
+        verified: true,
+        title: p.title,
+        category: p.category || void 0
+      }));
+      return entries;
+    } catch (error) {
+      console.warn(
+        `[PatternsProvider] Failed to get patterns for command ${command}:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      return [];
+    }
+  }
+  /**
+   * Check if source has patterns for a language.
+   */
+  async hasPatterns(language) {
+    const patterns = await this.getPatternsForLanguage(language);
+    return patterns.length > 0;
+  }
+  /**
+   * Get all supported languages.
+   */
+  async getSupportedLanguages() {
+    if (this.supportedLanguagesCache) {
+      return this.supportedLanguagesCache;
+    }
+    try {
+      const db = getDatabase({ ...this.options, readonly: true });
+      const result = db.prepare(
+        `
+        SELECT DISTINCT language FROM pattern_translations
+        WHERE verified_parses = 1
+      `
+      ).all();
+      this.supportedLanguagesCache = result.map((r) => r.language);
+      return this.supportedLanguagesCache;
+    } catch (error) {
+      console.warn(
+        "[PatternsProvider] Failed to get supported languages:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return [];
+    }
+  }
+  /**
+   * Clear the pattern cache.
+   */
+  clearCache() {
+    this.languageCache.clear();
+    this.supportedLanguagesCache = null;
+  }
+  /**
+   * Extract primary command from hyperscript code.
+   */
+  extractCommand(code) {
+    const match = code.match(/^(?:on\s+\w+\s+)?(\w+)/i);
+    if (match) {
+      const keyword = match[1].toLowerCase();
+      const commands = [
+        "toggle",
+        "add",
+        "remove",
+        "put",
+        "set",
+        "show",
+        "hide",
+        "wait",
+        "log",
+        "send",
+        "fetch",
+        "call",
+        "trigger",
+        "transition",
+        "increment",
+        "decrement"
+      ];
+      if (commands.includes(keyword)) {
+        return keyword;
+      }
+    }
+    return null;
+  }
+};
+var defaultProvider = null;
+function getDefaultProvider(options) {
+  if (!defaultProvider) {
+    defaultProvider = new DatabasePatternsProvider(options);
+  }
+  return defaultProvider;
+}
+function createPatternsProvider(options) {
+  return new DatabasePatternsProvider(options);
+}
+function resetDefaultProvider() {
+  if (defaultProvider) {
+    defaultProvider.clearCache();
+    defaultProvider = null;
+  }
+}
+
+// src/semantic-bridge.ts
+var bridgeInitialized = false;
+var bridgeProvider = null;
+async function initializeSemanticIntegration(options) {
+  const provider = options?.provider || createPatternsProvider(options);
+  bridgeProvider = provider;
+  try {
+    const semantic = await import('@lokascript/semantic');
+    if (typeof semantic.registerPatternsSource === "function") {
+      semantic.registerPatternsSource(provider);
+      bridgeInitialized = true;
+      return {
+        success: true,
+        provider,
+        registeredWith: "semantic"
+      };
+    } else {
+      console.warn(
+        "[SemanticBridge] @lokascript/semantic does not export registerPatternsSource. Running in standalone mode."
+      );
+      return {
+        success: true,
+        provider,
+        registeredWith: "standalone"
+      };
+    }
+  } catch (error) {
+    console.warn(
+      "[SemanticBridge] @lokascript/semantic not available:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return {
+      success: true,
+      provider,
+      registeredWith: "standalone",
+      error: "@lokascript/semantic not available"
+    };
+  }
+}
+function isSemanticIntegrationInitialized() {
+  return bridgeInitialized;
+}
+function getBridgeProvider() {
+  return bridgeProvider;
+}
+async function uninitializeSemanticIntegration() {
+  if (!bridgeProvider) {
+    return;
+  }
+  try {
+    const semantic = await import('@lokascript/semantic');
+    if (typeof semantic.unregisterPatternsSource === "function") {
+      semantic.unregisterPatternsSource(bridgeProvider.id);
+    }
+  } catch {
+  }
+  bridgeProvider.clearCache();
+  bridgeProvider = null;
+  bridgeInitialized = false;
+}
+async function queryPatterns(language) {
+  const provider = bridgeProvider || createPatternsProvider();
+  return provider.getPatternsForLanguage(language);
+}
+async function queryPatternsForCommand(command, language) {
+  const provider = bridgeProvider || createPatternsProvider();
+  return provider.getPatternsForCommand(command, language);
+}
+async function getSupportedLanguages() {
+  const provider = bridgeProvider || createPatternsProvider();
+  return provider.getSupportedLanguages();
+}
+
+// src/index.ts
+function createPatternsReference(options) {
+  getDatabase(options);
+  return {
+    // Patterns
+    getPatternById: (id) => getPatternById(id, options),
+    getPatternsByCategory: (category) => getPatternsByCategory(category, options),
+    getPatternsByCommand: (command) => getPatternsByCommand(command, options),
+    searchPatterns: (query, searchOptions) => searchPatterns(query, searchOptions, options),
+    // Translations
+    getTranslation: (patternId, language) => getTranslation(patternId, language, options),
+    getAllTranslations: (patternId) => getAllTranslations(patternId, options),
+    verifyTranslation: (translation) => verifyTranslation(translation, options),
+    // LLM
+    getLLMExamples: (prompt, language, limit) => getLLMExamples(prompt, language, limit, options),
+    // Stats
+    getStats: () => getPatternStats(options),
+    // Connection
+    close: closeDatabase
+  };
+}
+var VERSION = "0.1.0";
+
+exports.DatabasePatternsProvider = DatabasePatternsProvider;
+exports.VERSION = VERSION;
+exports.addLLMExample = addLLMExample;
+exports.buildFewShotContext = buildFewShotContext;
+exports.buildFewShotContextSync = buildFewShotContextSync;
+exports.closeDatabase = closeDatabase;
+exports.createLLMAdapter = createLLMAdapter;
+exports.createPatternsProvider = createPatternsProvider;
+exports.createPatternsReference = createPatternsReference;
+exports.discoverPatterns = discoverPatterns;
+exports.findExamplesByCommand = findExamplesByCommand;
+exports.findRelevantExamples = findRelevantExamples;
+exports.getAllCommands = getAllCommands;
+exports.getAllExpressions = getAllExpressions;
+exports.getAllFeatures = getAllFeatures;
+exports.getAllKeywords = getAllKeywords;
+exports.getAllPatterns = getAllPatterns;
+exports.getAllSpecialSymbols = getAllSpecialSymbols;
+exports.getAllTranslations = getAllTranslations;
+exports.getBridgeProvider = getBridgeProvider;
+exports.getCommandByName = getCommandByName;
+exports.getCurrentDbPath = getCurrentDbPath;
+exports.getDatabase = getDatabase;
+exports.getDefaultProvider = getDefaultProvider;
+exports.getExamplesByCommand = getExamplesByCommand;
+exports.getExpressionByName = getExpressionByName;
+exports.getExpressionsByCategory = getExpressionsByCategory;
+exports.getFeatureByName = getFeatureByName;
+exports.getHighConfidenceTranslations = getHighConfidenceTranslations;
+exports.getHighQualityExamples = getHighQualityExamples;
+exports.getKeywordByName = getKeywordByName;
+exports.getLLMExampleStats = getLLMExampleStats;
+exports.getLLMExamples = getLLMExamples;
+exports.getLLMStats = getLLMStats;
+exports.getLanguageDocsStats = getLanguageDocsStats;
+exports.getMostUsedExamples = getMostUsedExamples;
+exports.getPatternById = getPatternById;
+exports.getPatternStats = getPatternStats;
+exports.getPatternsByCategory = getPatternsByCategory;
+exports.getPatternsByCommand = getPatternsByCommand;
+exports.getSpecialSymbolByName = getSpecialSymbolByName;
+exports.getSupportedLanguages = getSupportedLanguages;
+exports.getTranslation = getTranslation;
+exports.getTranslationStats = getTranslationStats;
+exports.getTranslationsByLanguage = getTranslationsByLanguage;
+exports.getVerifiedTranslations = getVerifiedTranslations;
+exports.getWordOrder = getWordOrder;
+exports.initializeSemanticIntegration = initializeSemanticIntegration;
+exports.isConnected = isConnected;
+exports.isDatabaseAvailable = isDatabaseAvailable;
+exports.isSemanticIntegrationInitialized = isSemanticIntegrationInitialized;
+exports.queryPatterns = queryPatterns;
+exports.queryPatternsForCommand = queryPatternsForCommand;
+exports.resetConnection = resetConnection;
+exports.resetDefaultProvider = resetDefaultProvider;
+exports.searchCommands = searchCommands;
+exports.searchLanguageElements = searchLanguageElements;
+exports.searchPatterns = searchPatterns;
+exports.seedLLMExamples = seedLLMExamples;
+exports.syncTranslations = syncTranslations;
+exports.trackExampleUsage = trackExampleUsage;
+exports.uninitializeSemanticIntegration = uninitializeSemanticIntegration;
+exports.updateQualityScore = updateQualityScore;
+exports.validateAllTranslations = validateAllTranslations;
+exports.verifyTranslation = verifyTranslation;