prompts.chat 0.0.1 → 0.0.3

package/dist/similarity/index.mjs

@@ -0,0 +1,91 @@
+// src/similarity/index.ts
+function normalizeContent(content) {
+  return content.replace(/\$\{[^}]+\}/g, "").replace(/\[[^\]]+\]/g, "").replace(/<[^>]+>/g, "").toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function jaccardSimilarity(str1, str2) {
+  const set1 = new Set(str1.split(" ").filter(Boolean));
+  const set2 = new Set(str2.split(" ").filter(Boolean));
+  if (set1.size === 0 && set2.size === 0) return 1;
+  if (set1.size === 0 || set2.size === 0) return 0;
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function ngramSimilarity(str1, str2, n = 3) {
+  const getNgrams = (str) => {
+    const ngrams = /* @__PURE__ */ new Set();
+    const padded = " ".repeat(n - 1) + str + " ".repeat(n - 1);
+    for (let i = 0; i <= padded.length - n; i++) {
+      ngrams.add(padded.slice(i, i + n));
+    }
+    return ngrams;
+  };
+  const ngrams1 = getNgrams(str1);
+  const ngrams2 = getNgrams(str2);
+  if (ngrams1.size === 0 && ngrams2.size === 0) return 1;
+  if (ngrams1.size === 0 || ngrams2.size === 0) return 0;
+  const intersection = new Set([...ngrams1].filter((x) => ngrams2.has(x)));
+  const union = /* @__PURE__ */ new Set([...ngrams1, ...ngrams2]);
+  return intersection.size / union.size;
+}
+function calculateSimilarity(content1, content2) {
+  const normalized1 = normalizeContent(content1);
+  const normalized2 = normalizeContent(content2);
+  if (normalized1 === normalized2) return 1;
+  if (!normalized1 || !normalized2) return 0;
+  const jaccard = jaccardSimilarity(normalized1, normalized2);
+  const ngram = ngramSimilarity(normalized1, normalized2);
+  return jaccard * 0.6 + ngram * 0.4;
+}
+var calculate = calculateSimilarity;
+function isSimilarContent(content1, content2, threshold = 0.85) {
+  return calculateSimilarity(content1, content2) >= threshold;
+}
+var isDuplicate = isSimilarContent;
+function getContentFingerprint(content) {
+  const normalized = normalizeContent(content);
+  return normalized.slice(0, 500);
+}
+function findDuplicates(prompts, threshold = 0.85) {
+  const groups = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < prompts.length; i++) {
+    if (used.has(i)) continue;
+    const group = [prompts[i]];
+    used.add(i);
+    for (let j = i + 1; j < prompts.length; j++) {
+      if (used.has(j)) continue;
+      if (isSimilarContent(prompts[i].content, prompts[j].content, threshold)) {
+        group.push(prompts[j]);
+        used.add(j);
+      }
+    }
+    if (group.length > 1) {
+      groups.push(group);
+    }
+  }
+  return groups;
+}
+function deduplicate(prompts, threshold = 0.85) {
+  const result = [];
+  for (const prompt of prompts) {
+    const isDupe = result.some(
+      (existing) => isSimilarContent(existing.content, prompt.content, threshold)
+    );
+    if (!isDupe) {
+      result.push(prompt);
+    }
+  }
+  return result;
+}
+export {
+  calculate,
+  calculateSimilarity,
+  deduplicate,
+  findDuplicates,
+  getContentFingerprint,
+  isDuplicate,
+  isSimilarContent,
+  normalizeContent
+};
+//# sourceMappingURL=index.mjs.map

package/dist/similarity/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/similarity/index.ts"],"sourcesContent":["/**\n * Content similarity utilities for duplicate detection\n */\n\n/**\n * Normalize content for comparison by:\n * - Removing variables (${...} patterns)\n * - Converting to lowercase\n * - Removing extra whitespace\n * - Removing punctuation\n */\nexport function normalizeContent(content: string): string {\n  return content\n    // Remove variables like ${variable} or ${variable:default}\n    .replace(/\\$\\{[^}]+\\}/g, \"\")\n    // Remove common placeholder patterns like [placeholder] or <placeholder>\n    .replace(/\\[[^\\]]+\\]/g, \"\")\n    .replace(/<[^>]+>/g, \"\")\n    // Convert to lowercase\n    .toLowerCase()\n    // Remove punctuation\n    .replace(/[^\\w\\s]/g, \"\")\n    // Normalize whitespace\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n\n/**\n * Calculate Jaccard similarity between two strings\n * Returns a value between 0 (completely different) and 1 (identical)\n */\nfunction jaccardSimilarity(str1: string, str2: string): number {\n  const set1 = new Set(str1.split(\" \").filter(Boolean));\n  const set2 = new Set(str2.split(\" \").filter(Boolean));\n  \n  if (set1.size === 0 && set2.size === 0) return 1;\n  if (set1.size === 0 || set2.size === 0) return 0;\n  \n  const intersection = new Set([...set1].filter(x => set2.has(x)));\n  const union = new Set([...set1, ...set2]);\n  \n  return intersection.size / union.size;\n}\n\n/**\n * Calculate n-gram similarity for better sequence matching\n * Uses trigrams (3-character sequences) by default\n */\nfunction ngramSimilarity(str1: string, str2: string, n: number = 3): number {\n  const getNgrams = (str: string): Set<string> => {\n    const ngrams = new Set<string>();\n    const padded = \" \".repeat(n - 1) + str + \" \".repeat(n - 1);\n    for (let i = 0; i <= padded.length - n; i++) {\n      ngrams.add(padded.slice(i, i + n));\n    }\n    return ngrams;\n  };\n  \n  const ngrams1 = getNgrams(str1);\n  const ngrams2 = getNgrams(str2);\n  \n  if (ngrams1.size === 0 && ngrams2.size === 0) return 1;\n  if (ngrams1.size === 0 || ngrams2.size === 0) return 0;\n  \n  const intersection = new Set([...ngrams1].filter(x => ngrams2.has(x)));\n  const union = new Set([...ngrams1, ...ngrams2]);\n  \n  return intersection.size / union.size;\n}\n\n/**\n * Combined similarity score using multiple algorithms\n * Returns a value between 0 (completely different) and 1 (identical)\n */\nexport function calculateSimilarity(content1: string, content2: string): number {\n  const normalized1 = normalizeContent(content1);\n  const normalized2 = normalizeContent(content2);\n  \n  // Exact match after normalization\n  if (normalized1 === normalized2) return 1;\n  \n  // Empty content edge case\n  if (!normalized1 || !normalized2) return 0;\n  \n  // Combine Jaccard (word-level) and n-gram (character-level) similarities\n  const jaccard = jaccardSimilarity(normalized1, normalized2);\n  const ngram = ngramSimilarity(normalized1, normalized2);\n  \n  // Weighted average: 60% Jaccard (word overlap), 40% n-gram (sequence similarity)\n  return jaccard * 0.6 + ngram * 0.4;\n}\n\n/**\n * Alias for calculateSimilarity\n */\nexport const calculate = calculateSimilarity;\n\n/**\n * Check if two contents are similar enough to be considered duplicates\n * Default threshold is 0.85 (85% similar)\n */\nexport function isSimilarContent(\n  content1: string, \n  content2: string, \n  threshold: number = 0.85\n): boolean {\n  return calculateSimilarity(content1, content2) >= threshold;\n}\n\n/**\n * Alias for isSimilarContent\n */\nexport const isDuplicate = isSimilarContent;\n\n/**\n * Get normalized content hash for database indexing/comparison\n * This is a simple hash for quick lookups before full similarity check\n */\nexport function getContentFingerprint(content: string): string {\n  const normalized = normalizeContent(content);\n  // Take first 500 chars of normalized content as fingerprint\n  return normalized.slice(0, 500);\n}\n\n/**\n * Find duplicates in an array of prompts\n * Returns groups of similar prompts\n */\nexport function findDuplicates<T extends { content: string }>(\n  prompts: T[],\n  threshold: number = 0.85\n): T[][] {\n  const groups: T[][] = [];\n  const used = new Set<number>();\n\n  for (let i = 0; i < prompts.length; i++) {\n    if (used.has(i)) continue;\n\n    const group: T[] = [prompts[i]];\n    used.add(i);\n\n    for (let j = i + 1; j < prompts.length; j++) {\n      if (used.has(j)) continue;\n\n      if (isSimilarContent(prompts[i].content, prompts[j].content, threshold)) {\n        group.push(prompts[j]);\n        used.add(j);\n      }\n    }\n\n    if (group.length > 1) {\n      groups.push(group);\n    }\n  }\n\n  return groups;\n}\n\n/**\n * Deduplicate an array of prompts, keeping the first occurrence\n */\nexport function deduplicate<T extends { content: string }>(\n  prompts: T[],\n  threshold: number = 0.85\n): T[] {\n  const result: T[] = [];\n\n  for (const prompt of prompts) {\n    const isDupe = result.some(existing => \n      isSimilarContent(existing.content, prompt.content, threshold)\n    );\n\n    if (!isDupe) {\n      result.push(prompt);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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","names":[]}

package/dist/variables/index.d.mts

@@ -0,0 +1 @@
+export { D as DetectedVariable, V as VariablePattern, b as compile, a as convertAllVariables, c as convertToSupportedFormat, f as detect, d as detectVariables, e as extractVariables, g as getPatternDescription, n as normalize } from '../index-DOz8zcA0.mjs';

package/dist/variables/index.d.ts

@@ -0,0 +1 @@
+export { D as DetectedVariable, V as VariablePattern, b as compile, a as convertAllVariables, c as convertToSupportedFormat, f as detect, d as detectVariables, e as extractVariables, g as getPatternDescription, n as normalize } from '../index-DOz8zcA0.js';

package/dist/variables/index.js

@@ -0,0 +1,306 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/variables/index.ts
+var variables_exports = {};
+__export(variables_exports, {
+  compile: () => compile,
+  convertAllVariables: () => convertAllVariables,
+  convertToSupportedFormat: () => convertToSupportedFormat,
+  detect: () => detect,
+  detectVariables: () => detectVariables,
+  extractVariables: () => extractVariables,
+  getPatternDescription: () => getPatternDescription,
+  normalize: () => normalize
+});
+module.exports = __toCommonJS(variables_exports);
+var PATTERNS = [
+  // Double bracket: [[name]] or [[ name ]] or [[name: default]]
+  {
+    pattern: "double_bracket",
+    regex: /\[\[\s*([a-zA-Z_][a-zA-Z0-9_\s]*?)(?:\s*:\s*([^\]]*?))?\s*\]\]/g,
+    extractName: (m) => m[1].trim(),
+    extractDefault: (m) => m[2]?.trim()
+  },
+  // Double curly: {{name}} or {{ name }} or {{name: default}}
+  {
+    pattern: "double_curly",
+    regex: /\{\{\s*([a-zA-Z_][a-zA-Z0-9_\s]*?)(?:\s*:\s*([^}]*?))?\s*\}\}/g,
+    extractName: (m) => m[1].trim(),
+    extractDefault: (m) => m[2]?.trim()
+  },
+  // Our supported format (to exclude from warnings)
+  {
+    pattern: "dollar_curly",
+    regex: /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Single bracket with uppercase or placeholder-like: [NAME] or [Your Name]
+  {
+    pattern: "single_bracket",
+    regex: /\[([A-Z][A-Z0-9_\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\s+[A-Za-z][a-zA-Z0-9_]*)*)\]/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Single curly with uppercase: {NAME} or {Your Name}
+  {
+    pattern: "single_curly",
+    regex: /\{([A-Z][A-Z0-9_\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\s+[A-Za-z][a-zA-Z0-9_]*)*)\}/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Angle brackets: <NAME> or <name>
+  {
+    pattern: "angle_bracket",
+    regex: /<([A-Z][A-Z0-9_\s]*|[a-zA-Z_][a-zA-Z0-9_\s]*)>/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Percent signs: %NAME% or %name%
+  {
+    pattern: "percent",
+    regex: /%([a-zA-Z_][a-zA-Z0-9_]*)%/g,
+    extractName: (m) => m[1].trim()
+  }
+];
+var FALSE_POSITIVES = /* @__PURE__ */ new Set([
+  // HTML/XML common tags
+  "div",
+  "span",
+  "p",
+  "a",
+  "br",
+  "hr",
+  "img",
+  "input",
+  "button",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "tr",
+  "td",
+  "th",
+  "thead",
+  "tbody",
+  "form",
+  "label",
+  "select",
+  "option",
+  "textarea",
+  "script",
+  "style",
+  "link",
+  "meta",
+  "head",
+  "body",
+  "html",
+  "section",
+  "article",
+  "nav",
+  "header",
+  "footer",
+  "main",
+  "aside",
+  "figure",
+  "figcaption",
+  "strong",
+  "em",
+  "code",
+  "pre",
+  "blockquote",
+  "cite",
+  "abbr",
+  "address",
+  "b",
+  "i",
+  "u",
+  // Common programming constructs
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "return",
+  "function",
+  "class",
+  "const",
+  "let",
+  "var",
+  "import",
+  "export",
+  "default",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "new",
+  "this",
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "typeof",
+  "instanceof",
+  // JSON structure keywords (when in context)
+  "type",
+  "id",
+  "key",
+  "value",
+  "data",
+  "items",
+  "properties"
+]);
+function isInsideJsonString(text, index) {
+  let inString = false;
+  for (let i = 0; i < index; i++) {
+    if (text[i] === '"' && (i === 0 || text[i - 1] !== "\\")) {
+      inString = !inString;
+    }
+  }
+  return inString;
+}
+function detectVariables(text) {
+  const detected = [];
+  const seenRanges = [];
+  const supportedVars = /* @__PURE__ */ new Set();
+  const dollarCurlyPattern = /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g;
+  let match;
+  while ((match = dollarCurlyPattern.exec(text)) !== null) {
+    seenRanges.push([match.index, match.index + match[0].length]);
+    supportedVars.add(match[0]);
+  }
+  for (const config of PATTERNS) {
+    if (config.pattern === "dollar_curly") continue;
+    const regex = new RegExp(config.regex.source, config.regex.flags);
+    while ((match = regex.exec(text)) !== null) {
+      const startIndex = match.index;
+      const endIndex = startIndex + match[0].length;
+      const overlaps = seenRanges.some(
+        ([start, end]) => startIndex >= start && startIndex < end || endIndex > start && endIndex <= end
+      );
+      if (overlaps) continue;
+      const name = config.extractName(match);
+      if (FALSE_POSITIVES.has(name.toLowerCase())) continue;
+      if (name.length < 2) continue;
+      if (config.pattern === "angle_bracket") {
+        if (!/^[A-Z]/.test(name) && !name.includes(" ")) continue;
+      }
+      if ((config.pattern === "single_curly" || config.pattern === "single_bracket") && isInsideJsonString(text, startIndex)) {
+        if (!/^[A-Z]/.test(name) && !name.includes(" ")) continue;
+      }
+      const defaultValue = config.extractDefault?.(match);
+      detected.push({
+        original: match[0],
+        name,
+        defaultValue,
+        pattern: config.pattern,
+        startIndex,
+        endIndex
+      });
+      seenRanges.push([startIndex, endIndex]);
+    }
+  }
+  return detected.sort((a, b) => a.startIndex - b.startIndex).filter(
+    (v, i, arr) => i === 0 || v.original !== arr[i - 1].original || v.startIndex !== arr[i - 1].startIndex
+  );
+}
+function convertToSupportedFormat(variable) {
+  const normalizedName = variable.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "");
+  if (variable.defaultValue) {
+    return `\${${normalizedName}:${variable.defaultValue}}`;
+  }
+  return `\${${normalizedName}}`;
+}
+function convertAllVariables(text) {
+  const detected = detectVariables(text);
+  if (detected.length === 0) return text;
+  const sorted = [...detected].sort((a, b) => b.startIndex - a.startIndex);
+  let result = text;
+  for (const variable of sorted) {
+    const converted = convertToSupportedFormat(variable);
+    result = result.slice(0, variable.startIndex) + converted + result.slice(variable.endIndex);
+  }
+  return result;
+}
+var normalize = convertAllVariables;
+var detect = detectVariables;
+function getPatternDescription(pattern) {
+  switch (pattern) {
+    case "double_bracket":
+      return "[[...]]";
+    case "double_curly":
+      return "{{...}}";
+    case "single_bracket":
+      return "[...]";
+    case "single_curly":
+      return "{...}";
+    case "angle_bracket":
+      return "<...>";
+    case "percent":
+      return "%...%";
+    case "dollar_curly":
+      return "${...}";
+  }
+}
+function extractVariables(text) {
+  const regex = /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g;
+  const variables = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    variables.push({
+      name: match[1].trim(),
+      defaultValue: match[2]?.trim()
+    });
+  }
+  return variables;
+}
+function compile(template, values, options = {}) {
+  const { useDefaults = true } = options;
+  return template.replace(
+    /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g,
+    (match, name, defaultValue) => {
+      const trimmedName = name.trim();
+      if (trimmedName in values) {
+        return values[trimmedName];
+      }
+      if (useDefaults && defaultValue !== void 0) {
+        return defaultValue.trim();
+      }
+      return match;
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  convertAllVariables,
+  convertToSupportedFormat,
+  detect,
+  detectVariables,
+  extractVariables,
+  getPatternDescription,
+  normalize
+});
+//# sourceMappingURL=index.js.map

package/dist/variables/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/variables/index.ts"],"sourcesContent":["/**\n * Variable Detection Utility\n * Detects common variable-like patterns in text that could be converted\n * to our supported format: ${variableName} or ${variableName:default}\n */\n\nexport interface DetectedVariable {\n  original: string;\n  name: string;\n  defaultValue?: string;\n  pattern: VariablePattern;\n  startIndex: number;\n  endIndex: number;\n}\n\nexport type VariablePattern = \n  | \"double_bracket\"      // [[name]] or [[ name ]]\n  | \"double_curly\"        // {{name}} or {{ name }}\n  | \"single_bracket\"      // [NAME] or [name]\n  | \"single_curly\"        // {NAME} or {name}\n  | \"angle_bracket\"       // <NAME> or <name>\n  | \"percent\"             // %NAME% or %name%\n  | \"dollar_curly\";       // ${name} (already our format)\n\ninterface PatternConfig {\n  pattern: VariablePattern;\n  regex: RegExp;\n  extractName: (match: RegExpExecArray) => string;\n  extractDefault?: (match: RegExpExecArray) => string | undefined;\n}\n\n// Patterns to detect, ordered by specificity (more specific first)\nconst PATTERNS: PatternConfig[] = [\n  // Double bracket: [[name]] or [[ name ]] or [[name: default]]\n  {\n    pattern: \"double_bracket\",\n    regex: /\\[\\[\\s*([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?:\\s*:\\s*([^\\]]*?))?\\s*\\]\\]/g,\n    extractName: (m) => m[1].trim(),\n    extractDefault: (m) => m[2]?.trim(),\n  },\n  // Double curly: {{name}} or {{ name }} or {{name: default}}\n  {\n    pattern: \"double_curly\",\n    regex: /\\{\\{\\s*([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?:\\s*:\\s*([^}]*?))?\\s*\\}\\}/g,\n    extractName: (m) => m[1].trim(),\n    extractDefault: (m) => m[2]?.trim(),\n  },\n  // Our supported format (to exclude from warnings)\n  {\n    pattern: \"dollar_curly\",\n    regex: /\\$\\{([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?::([^}]*))?\\}/g,\n    extractName: (m) => m[1].trim(),\n  },\n  // Single bracket with uppercase or placeholder-like: [NAME] or [Your Name]\n  {\n    pattern: \"single_bracket\",\n    regex: /\\[([A-Z][A-Z0-9_\\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\\s+[A-Za-z][a-zA-Z0-9_]*)*)\\]/g,\n    extractName: (m) => m[1].trim(),\n  },\n  // Single curly with uppercase: {NAME} or {Your Name}\n  {\n    pattern: \"single_curly\",\n    regex: /\\{([A-Z][A-Z0-9_\\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\\s+[A-Za-z][a-zA-Z0-9_]*)*)\\}/g,\n    extractName: (m) => m[1].trim(),\n  },\n  // Angle brackets: <NAME> or <name>\n  {\n    pattern: \"angle_bracket\",\n    regex: /<([A-Z][A-Z0-9_\\s]*|[a-zA-Z_][a-zA-Z0-9_\\s]*)>/g,\n    extractName: (m) => m[1].trim(),\n  },\n  // Percent signs: %NAME% or %name%\n  {\n    pattern: \"percent\",\n    regex: /%([a-zA-Z_][a-zA-Z0-9_]*)%/g,\n    extractName: (m) => m[1].trim(),\n  },\n];\n\n// Common false positives to ignore\nconst FALSE_POSITIVES = new Set([\n  // HTML/XML common tags\n  \"div\", \"span\", \"p\", \"a\", \"br\", \"hr\", \"img\", \"input\", \"button\",\n  \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"ul\", \"ol\", \"li\", \"table\",\n  \"tr\", \"td\", \"th\", \"thead\", \"tbody\", \"form\", \"label\", \"select\",\n  \"option\", \"textarea\", \"script\", \"style\", \"link\", \"meta\", \"head\",\n  \"body\", \"html\", \"section\", \"article\", \"nav\", \"header\", \"footer\",\n  \"main\", \"aside\", \"figure\", \"figcaption\", \"strong\", \"em\", \"code\",\n  \"pre\", \"blockquote\", \"cite\", \"abbr\", \"address\", \"b\", \"i\", \"u\",\n  // Common programming constructs\n  \"if\", \"else\", \"for\", \"while\", \"switch\", \"case\", \"break\", \"return\",\n  \"function\", \"class\", \"const\", \"let\", \"var\", \"import\", \"export\",\n  \"default\", \"try\", \"catch\", \"finally\", \"throw\", \"new\", \"this\",\n  \"null\", \"undefined\", \"true\", \"false\", \"typeof\", \"instanceof\",\n  // JSON structure keywords (when in context)\n  \"type\", \"id\", \"key\", \"value\", \"data\", \"items\", \"properties\",\n]);\n\n/**\n * Check if we're inside a JSON string context\n */\nfunction isInsideJsonString(text: string, index: number): boolean {\n  let inString = false;\n  for (let i = 0; i < index; i++) {\n    if (text[i] === '\"' && (i === 0 || text[i - 1] !== '\\\\')) {\n      inString = !inString;\n    }\n  }\n  return inString;\n}\n\n/**\n * Detect variable-like patterns in text\n * Returns detected variables that are NOT in our supported format\n */\nexport function detectVariables(text: string): DetectedVariable[] {\n  const detected: DetectedVariable[] = [];\n  const seenRanges: Array<[number, number]> = [];\n  \n  // Track our supported format positions to exclude them\n  const supportedVars = new Set<string>();\n  const dollarCurlyPattern = /\\$\\{([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?::([^}]*))?\\}/g;\n  let match: RegExpExecArray | null;\n  \n  while ((match = dollarCurlyPattern.exec(text)) !== null) {\n    seenRanges.push([match.index, match.index + match[0].length]);\n    supportedVars.add(match[0]);\n  }\n  \n  // Check each pattern\n  for (const config of PATTERNS) {\n    // Skip our supported format pattern for detection\n    if (config.pattern === \"dollar_curly\") continue;\n    \n    const regex = new RegExp(config.regex.source, config.regex.flags);\n    \n    while ((match = regex.exec(text)) !== null) {\n      const startIndex = match.index;\n      const endIndex = startIndex + match[0].length;\n      \n      // Check if this range overlaps with any already detected range\n      const overlaps = seenRanges.some(\n        ([start, end]) => \n          (startIndex >= start && startIndex < end) ||\n          (endIndex > start && endIndex <= end)\n      );\n      \n      if (overlaps) continue;\n      \n      const name = config.extractName(match);\n      \n      // Skip false positives\n      if (FALSE_POSITIVES.has(name.toLowerCase())) continue;\n      \n      // Skip very short names (likely not variables)\n      if (name.length < 2) continue;\n      \n      // For angle brackets, be more strict\n      if (config.pattern === \"angle_bracket\") {\n        if (!/^[A-Z]/.test(name) && !name.includes(\" \")) continue;\n      }\n      \n      // For single curly/bracket in JSON context, be more careful\n      if (\n        (config.pattern === \"single_curly\" || config.pattern === \"single_bracket\") &&\n        isInsideJsonString(text, startIndex)\n      ) {\n        if (!/^[A-Z]/.test(name) && !name.includes(\" \")) continue;\n      }\n      \n      const defaultValue = config.extractDefault?.(match);\n      \n      detected.push({\n        original: match[0],\n        name,\n        defaultValue,\n        pattern: config.pattern,\n        startIndex,\n        endIndex,\n      });\n      \n      seenRanges.push([startIndex, endIndex]);\n    }\n  }\n  \n  // Sort by position and remove duplicates\n  return detected\n    .sort((a, b) => a.startIndex - b.startIndex)\n    .filter((v, i, arr) => \n      i === 0 || v.original !== arr[i - 1].original || v.startIndex !== arr[i - 1].startIndex\n    );\n}\n\n/**\n * Convert a detected variable to our supported format\n */\nexport function convertToSupportedFormat(variable: DetectedVariable): string {\n  // Normalize name: lowercase, replace spaces with underscores\n  const normalizedName = variable.name\n    .toLowerCase()\n    .replace(/\\s+/g, \"_\")\n    .replace(/[^a-z0-9_]/g, \"\");\n  \n  if (variable.defaultValue) {\n    return `\\${${normalizedName}:${variable.defaultValue}}`;\n  }\n  \n  return `\\${${normalizedName}}`;\n}\n\n/**\n * Convert all detected variables in text to our supported format\n */\nexport function convertAllVariables(text: string): string {\n  const detected = detectVariables(text);\n  \n  if (detected.length === 0) return text;\n  \n  // Sort by position descending to replace from end to start\n  const sorted = [...detected].sort((a, b) => b.startIndex - a.startIndex);\n  \n  let result = text;\n  for (const variable of sorted) {\n    const converted = convertToSupportedFormat(variable);\n    result = result.slice(0, variable.startIndex) + converted + result.slice(variable.endIndex);\n  }\n  \n  return result;\n}\n\n/**\n * Alias for convertAllVariables - normalizes all variable formats to ${var}\n */\nexport const normalize = convertAllVariables;\n\n/**\n * Alias for detectVariables\n */\nexport const detect = detectVariables;\n\n/**\n * Get a human-readable pattern description\n */\nexport function getPatternDescription(pattern: VariablePattern): string {\n  switch (pattern) {\n    case \"double_bracket\": return \"[[...]]\";\n    case \"double_curly\": return \"{{...}}\";\n    case \"single_bracket\": return \"[...]\";\n    case \"single_curly\": return \"{...}\";\n    case \"angle_bracket\": return \"<...>\";\n    case \"percent\": return \"%...%\";\n    case \"dollar_curly\": return \"${...}\";\n  }\n}\n\n/**\n * Extract variables from our supported ${var} or ${var:default} format\n */\nexport function extractVariables(text: string): Array<{ name: string; defaultValue?: string }> {\n  const regex = /\\$\\{([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?::([^}]*))?\\}/g;\n  const variables: Array<{ name: string; defaultValue?: string }> = [];\n  let match: RegExpExecArray | null;\n  \n  while ((match = regex.exec(text)) !== null) {\n    variables.push({\n      name: match[1].trim(),\n      defaultValue: match[2]?.trim(),\n    });\n  }\n  \n  return variables;\n}\n\n/**\n * Compile a prompt template with variable values\n */\nexport function compile(\n  template: string, \n  values: Record<string, string>,\n  options: { useDefaults?: boolean } = {}\n): string {\n  const { useDefaults = true } = options;\n  \n  return template.replace(\n    /\\$\\{([a-zA-Z_][a-zA-Z0-9_\\s]*?)(?::([^}]*))?\\}/g,\n    (match, name, defaultValue) => {\n      const trimmedName = name.trim();\n      if (trimmedName in values) {\n        return values[trimmedName];\n      }\n      if (useDefaults && defaultValue !== undefined) {\n        return defaultValue.trim();\n      }\n      return match; // Keep original if no value and no default\n    }\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,IAAM,WAA4B;AAAA;AAAA,EAEhC;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,IAC9B,gBAAgB,CAAC,MAAM,EAAE,CAAC,GAAG,KAAK;AAAA,EACpC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,IAC9B,gBAAgB,CAAC,MAAM,EAAE,CAAC,GAAG,KAAK;AAAA,EACpC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,EAChC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,EAChC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,EAChC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,EAChC;AAAA;AAAA,EAEA;AAAA,IACE,SAAS;AAAA,IACT,OAAO;AAAA,IACP,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK;AAAA,EAChC;AACF;AAGA,IAAM,kBAAkB,oBAAI,IAAI;AAAA;AAAA,EAE9B;AAAA,EAAO;AAAA,EAAQ;AAAA,EAAK;AAAA,EAAK;AAAA,EAAM;AAAA,EAAM;AAAA,EAAO;AAAA,EAAS;AAAA,EACrD;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EACtD;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAS;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAS;AAAA,EACrD;AAAA,EAAU;AAAA,EAAY;AAAA,EAAU;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAQ;AAAA,EACzD;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAW;AAAA,EAAW;AAAA,EAAO;AAAA,EAAU;AAAA,EACvD;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAU;AAAA,EAAc;AAAA,EAAU;AAAA,EAAM;AAAA,EACzD;AAAA,EAAO;AAAA,EAAc;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAW;AAAA,EAAK;AAAA,EAAK;AAAA;AAAA,EAE1D;AAAA,EAAM;AAAA,EAAQ;AAAA,EAAO;AAAA,EAAS;AAAA,EAAU;AAAA,EAAQ;AAAA,EAAS;AAAA,EACzD;AAAA,EAAY;AAAA,EAAS;AAAA,EAAS;AAAA,EAAO;AAAA,EAAO;AAAA,EAAU;AAAA,EACtD;AAAA,EAAW;AAAA,EAAO;AAAA,EAAS;AAAA,EAAW;AAAA,EAAS;AAAA,EAAO;AAAA,EACtD;AAAA,EAAQ;AAAA,EAAa;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAU;AAAA;AAAA,EAEhD;AAAA,EAAQ;AAAA,EAAM;AAAA,EAAO;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAS;AACjD,CAAC;AAKD,SAAS,mBAAmB,MAAc,OAAwB;AAChE,MAAI,WAAW;AACf,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC9B,QAAI,KAAK,CAAC,MAAM,QAAQ,MAAM,KAAK,KAAK,IAAI,CAAC,MAAM,OAAO;AACxD,iBAAW,CAAC;AAAA,IACd;AAAA,EACF;AACA,SAAO;AACT;AAMO,SAAS,gBAAgB,MAAkC;AAChE,QAAM,WAA+B,CAAC;AACtC,QAAM,aAAsC,CAAC;AAG7C,QAAM,gBAAgB,oBAAI,IAAY;AACtC,QAAM,qBAAqB;AAC3B,MAAI;AAEJ,UAAQ,QAAQ,mBAAmB,KAAK,IAAI,OAAO,MAAM;AACvD,eAAW,KAAK,CAAC,MAAM,OAAO,MAAM,QAAQ,MAAM,CAAC,EAAE,MAAM,CAAC;AAC5D,kBAAc,IAAI,MAAM,CAAC,CAAC;AAAA,EAC5B;AAGA,aAAW,UAAU,UAAU;AAE7B,QAAI,OAAO,YAAY,eAAgB;AAEvC,UAAM,QAAQ,IAAI,OAAO,OAAO,MAAM,QAAQ,OAAO,MAAM,KAAK;AAEhE,YAAQ,QAAQ,MAAM,KAAK,IAAI,OAAO,MAAM;AAC1C,YAAM,aAAa,MAAM;AACzB,YAAM,WAAW,aAAa,MAAM,CAAC,EAAE;AAGvC,YAAM,WAAW,WAAW;AAAA,QAC1B,CAAC,CAAC,OAAO,GAAG,MACT,cAAc,SAAS,aAAa,OACpC,WAAW,SAAS,YAAY;AAAA,MACrC;AAEA,UAAI,SAAU;AAEd,YAAM,OAAO,OAAO,YAAY,KAAK;AAGrC,UAAI,gBAAgB,IAAI,KAAK,YAAY,CAAC,EAAG;AAG7C,UAAI,KAAK,SAAS,EAAG;AAGrB,UAAI,OAAO,YAAY,iBAAiB;AACtC,YAAI,CAAC,SAAS,KAAK,IAAI,KAAK,CAAC,KAAK,SAAS,GAAG,EAAG;AAAA,MACnD;AAGA,WACG,OAAO,YAAY,kBAAkB,OAAO,YAAY,qBACzD,mBAAmB,MAAM,UAAU,GACnC;AACA,YAAI,CAAC,SAAS,KAAK,IAAI,KAAK,CAAC,KAAK,SAAS,GAAG,EAAG;AAAA,MACnD;AAEA,YAAM,eAAe,OAAO,iBAAiB,KAAK;AAElD,eAAS,KAAK;AAAA,QACZ,UAAU,MAAM,CAAC;AAAA,QACjB;AAAA,QACA;AAAA,QACA,SAAS,OAAO;AAAA,QAChB;AAAA,QACA;AAAA,MACF,CAAC;AAED,iBAAW,KAAK,CAAC,YAAY,QAAQ,CAAC;AAAA,IACxC;AAAA,EACF;AAGA,SAAO,SACJ,KAAK,CAAC,GAAG,MAAM,EAAE,aAAa,EAAE,UAAU,EAC1C;AAAA,IAAO,CAAC,GAAG,GAAG,QACb,MAAM,KAAK,EAAE,aAAa,IAAI,IAAI,CAAC,EAAE,YAAY,EAAE,eAAe,IAAI,IAAI,CAAC,EAAE;AAAA,EAC/E;AACJ;AAKO,SAAS,yBAAyB,UAAoC;AAE3E,QAAM,iBAAiB,SAAS,KAC7B,YAAY,EACZ,QAAQ,QAAQ,GAAG,EACnB,QAAQ,eAAe,EAAE;AAE5B,MAAI,SAAS,cAAc;AACzB,WAAO,MAAM,cAAc,IAAI,SAAS,YAAY;AAAA,EACtD;AAEA,SAAO,MAAM,cAAc;AAC7B;AAKO,SAAS,oBAAoB,MAAsB;AACxD,QAAM,WAAW,gBAAgB,IAAI;AAErC,MAAI,SAAS,WAAW,EAAG,QAAO;AAGlC,QAAM,SAAS,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,aAAa,EAAE,UAAU;AAEvE,MAAI,SAAS;AACb,aAAW,YAAY,QAAQ;AAC7B,UAAM,YAAY,yBAAyB,QAAQ;AACnD,aAAS,OAAO,MAAM,GAAG,SAAS,UAAU,IAAI,YAAY,OAAO,MAAM,SAAS,QAAQ;AAAA,EAC5F;AAEA,SAAO;AACT;AAKO,IAAM,YAAY;AAKlB,IAAM,SAAS;AAKf,SAAS,sBAAsB,SAAkC;AACtE,UAAQ,SAAS;AAAA,IACf,KAAK;AAAkB,aAAO;AAAA,IAC9B,KAAK;AAAgB,aAAO;AAAA,IAC5B,KAAK;AAAkB,aAAO;AAAA,IAC9B,KAAK;AAAgB,aAAO;AAAA,IAC5B,KAAK;AAAiB,aAAO;AAAA,IAC7B,KAAK;AAAW,aAAO;AAAA,IACvB,KAAK;AAAgB,aAAO;AAAA,EAC9B;AACF;AAKO,SAAS,iBAAiB,MAA8D;AAC7F,QAAM,QAAQ;AACd,QAAM,YAA4D,CAAC;AACnE,MAAI;AAEJ,UAAQ,QAAQ,MAAM,KAAK,IAAI,OAAO,MAAM;AAC1C,cAAU,KAAK;AAAA,MACb,MAAM,MAAM,CAAC,EAAE,KAAK;AAAA,MACpB,cAAc,MAAM,CAAC,GAAG,KAAK;AAAA,IAC/B,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAKO,SAAS,QACd,UACA,QACA,UAAqC,CAAC,GAC9B;AACR,QAAM,EAAE,cAAc,KAAK,IAAI;AAE/B,SAAO,SAAS;AAAA,IACd;AAAA,IACA,CAAC,OAAO,MAAM,iBAAiB;AAC7B,YAAM,cAAc,KAAK,KAAK;AAC9B,UAAI,eAAe,QAAQ;AACzB,eAAO,OAAO,WAAW;AAAA,MAC3B;AACA,UAAI,eAAe,iBAAiB,QAAW;AAC7C,eAAO,aAAa,KAAK;AAAA,MAC3B;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}