/**
 * 🧠 BRAINY EMBEDDED PATTERNS
 * 
 * AUTO-GENERATED - DO NOT EDIT
 * Generated: 2025-09-30T23:01:33.167Z
 * Patterns: 220
 * Coverage: 94-98% of all queries
 * 
 * This file contains ALL patterns and embeddings compiled into Brainy.
 * No external files needed, no runtime loading, instant availability!
 */

import type { Pattern } from './patternLibrary.js'

// All 220 patterns embedded directly
export const EMBEDDED_PATTERNS: Pattern[] = [
  {
    "id": "research_on",
    "category": "academic",
    "examples": [
      "research on AI safety",
      "papers about climate change",
      "studies on COVID"
    ],
    "pattern": "(?:research|papers?|studies)\\s+(?:on|about)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "academic"
      }
    },
    "confidence": 0.91
  },
  {
    "id": "aggregation_count",
    "category": "aggregation",
    "examples": [
      "count papers",
      "number of models",
      "how many datasets"
    ],
    "pattern": "(count|number of|how many) (.+)",
    "template": {
      "like": "${2}",
      "aggregate": "count"
    },
    "confidence": 0.9
  },
  {
    "id": "how_many",
    "category": "aggregation",
    "examples": [
      "how many papers about AI",
      "count of documents"
    ],
    "pattern": "(?:how\\s+many|count\\s+of|number\\s+of)\\s+(.+)",
    "template": {
      "like": "${1}",
      "aggregate": "count"
    },
    "confidence": 0.9
  },
  {
    "id": "list_of_all",
    "category": "aggregation",
    "examples": [
      "list of all features",
      "all available options",
      "complete list"
    ],
    "pattern": "(?:list\\s+of\\s+all|all\\s+available|complete\\s+list)\\s+(.+)",
    "template": {
      "like": "${1}",
      "limit": 1000
    },
    "confidence": 0.88
  },
  {
    "id": "aggregation_average",
    "category": "aggregation",
    "examples": [
      "average citations",
      "mean accuracy",
      "average performance"
    ],
    "pattern": "(average|mean) (.+)",
    "template": {
      "like": "${2}",
      "aggregate": "avg"
    },
    "confidence": 0.85
  },
  {
    "id": "aggregation_sum",
    "category": "aggregation",
    "examples": [
      "total citations",
      "sum of parameters",
      "total cost"
    ],
    "pattern": "(total|sum of|sum) (.+)",
    "template": {
      "like": "${2}",
      "aggregate": "sum"
    },
    "confidence": 0.85
  },
  {
    "id": "aggregation_max",
    "category": "aggregation",
    "examples": [
      "highest accuracy",
      "maximum performance",
      "largest model"
    ],
    "pattern": "(highest|maximum|largest|biggest) (.+)",
    "template": {
      "like": "${2}",
      "aggregate": "max"
    },
    "confidence": 0.85
  },
  {
    "id": "aggregation_min",
    "category": "aggregation",
    "examples": [
      "lowest error",
      "minimum cost",
      "smallest model"
    ],
    "pattern": "(lowest|minimum|smallest|least) (.+)",
    "template": {
      "like": "${2}",
      "aggregate": "min"
    },
    "confidence": 0.85
  },
  {
    "id": "average_of",
    "category": "aggregation",
    "examples": [
      "average citations",
      "mean score",
      "median value"
    ],
    "pattern": "(?:average|mean|median)\\s+(?:of\\s+)?(.+)",
    "template": {
      "like": "${1}",
      "aggregate": "average"
    },
    "confidence": 0.85
  },
  {
    "id": "and_but_not",
    "category": "combined",
    "examples": [
      "AI and ML but not deep learning",
      "Python and Django but not Flask"
    ],
    "pattern": "(.+?)\\s+and\\s+(.+?)\\s+but\\s+not\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "not": "${3}"
      }
    },
    "confidence": 0.82
  },
  {
    "id": "combined_complex_1",
    "category": "combined",
    "examples": [
      "recent papers by Hinton with more than 50 citations"
    ],
    "pattern": "recent (.+) by (.+) with more than (\\d+) (.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${2}"
      },
      "where": {
        "${4}": {
          "greaterThan": "${3}"
        }
      },
      "boost": "recent"
    },
    "confidence": 0.75
  },
  {
    "id": "combined_complex_2",
    "category": "combined",
    "examples": [
      "best machine learning papers from 2023 at Stanford"
    ],
    "pattern": "best (.+) from (\\d{4}) at (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "year": "${2}",
        "organization": "${3}"
      },
      "boost": "popular"
    },
    "confidence": 0.75
  },
  {
    "id": "combined_complex_3",
    "category": "combined",
    "examples": [
      "compare tensorflow and pytorch for computer vision"
    ],
    "pattern": "compare (.+) and (.+) for (.+)",
    "template": {
      "like": [
        "${1}",
        "${2}",
        "${3}"
      ],
      "where": {
        "type": "comparison",
        "domain": "${3}"
      }
    },
    "confidence": 0.75
  },
  {
    "id": "commercial_compare",
    "category": "commercial",
    "examples": [
      "tensorflow vs pytorch",
      "compare BERT and GPT",
      "GPT-3 compared to GPT-4"
    ],
    "pattern": "(.+) (vs|versus|compared to|vs\\.) (.+)",
    "template": {
      "like": [
        "${1}",
        "${3}"
      ],
      "where": {
        "type": "comparison"
      }
    },
    "confidence": 0.95
  },
  {
    "id": "commercial_reviews",
    "category": "commercial",
    "examples": [
      "tensorflow reviews",
      "best practices reviews",
      "model evaluation"
    ],
    "pattern": "(.+) (reviews|ratings|feedback|opinions)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "review"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "commercial_best",
    "category": "commercial",
    "examples": [
      "best machine learning framework",
      "top AI models",
      "best practices"
    ],
    "pattern": "(best|top|greatest|finest) (.+)",
    "template": {
      "like": "${2}",
      "boost": "popular"
    },
    "confidence": 0.9
  },
  {
    "id": "commercial_top_n",
    "category": "commercial",
    "examples": [
      "top 10 models",
      "top 5 papers",
      "best 3 frameworks"
    ],
    "pattern": "(top|best) (\\d+) (.+)",
    "template": {
      "like": "${3}",
      "limit": "${2}",
      "boost": "popular"
    },
    "confidence": 0.9
  },
  {
    "id": "price_cost",
    "category": "commercial",
    "examples": [
      "price of AWS",
      "cost of hosting",
      "pricing for services"
    ],
    "pattern": "(?:price|cost|pricing)\\s+(?:of|for)\\s+(.+)",
    "template": {
      "like": "${1} pricing",
      "where": {
        "type": "commercial"
      }
    },
    "confidence": 0.88
  },
  {
    "id": "free_open_source",
    "category": "commercial",
    "examples": [
      "free alternatives to",
      "open source version",
      "free tools for"
    ],
    "pattern": "(?:free|open\\s+source)\\s+(?:alternatives?\\s+to|version\\s+of|tools?\\s+for)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "license": "free"
      }
    },
    "confidence": 0.87
  },
  {
    "id": "commercial_alternatives",
    "category": "commercial",
    "examples": [
      "tensorflow alternatives",
      "options besides OpenAI",
      "similar to BERT"
    ],
    "pattern": "(.+) (alternatives|options|similar to|like)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "alternative"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "commercial_cheapest",
    "category": "commercial",
    "examples": [
      "cheapest GPU",
      "most affordable cloud",
      "budget options"
    ],
    "pattern": "(cheapest|most affordable|budget|lowest price) (.+)",
    "template": {
      "like": "${2}",
      "orderBy": {
        "price": "asc"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "commercial_pricing",
    "category": "commercial",
    "examples": [
      "GPU pricing",
      "cloud costs",
      "model training costs"
    ],
    "pattern": "(.+) (pricing|price|cost|costs|rates)",
    "template": {
      "like": "${1}",
      "where": {
        "hasField": "price"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "comparative_better",
    "category": "commercial",
    "examples": [
      "is BERT better than GPT",
      "pytorch better than tensorflow"
    ],
    "pattern": "(is )? (.+) better than (.+)",
    "template": {
      "like": [
        "${2}",
        "${3}"
      ],
      "where": {
        "type": "comparison"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "comparative_faster",
    "category": "commercial",
    "examples": [
      "fastest model",
      "quickest training",
      "faster than BERT"
    ],
    "pattern": "(fastest|quickest|faster) (.+)",
    "template": {
      "like": "${2}",
      "orderBy": {
        "speed": "desc"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "comparative_more_accurate",
    "category": "commercial",
    "examples": [
      "most accurate model",
      "higher accuracy than"
    ],
    "pattern": "(most accurate|highest accuracy|more accurate) (.+)",
    "template": {
      "like": "${2}",
      "orderBy": {
        "accuracy": "desc"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "question_which",
    "category": "commercial",
    "examples": [
      "which model is best",
      "which framework to use"
    ],
    "pattern": "which (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "selection"
      }
    },
    "confidence": 0.8
  },
  {
    "id": "comparison_vs",
    "category": "comparative",
    "examples": [
      "Python vs JavaScript",
      "React vs Vue",
      "TensorFlow vs PyTorch"
    ],
    "pattern": "(.+?)\\s+vs\\.?\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "boost": "comparison"
    },
    "confidence": 0.9
  },
  {
    "id": "difference_between",
    "category": "comparative",
    "examples": [
      "difference between AI and ML",
      "what's the difference between React and Angular"
    ],
    "pattern": "(?:difference|differences)\\s+between\\s+(.+?)\\s+and\\s+(.+)",
    "template": {
      "like": "${1} ${2} comparison",
      "boost": "comparison"
    },
    "confidence": 0.88
  },
  {
    "id": "alternative_instead",
    "category": "comparative",
    "examples": [
      "instead of React",
      "alternative to Python",
      "replacement for"
    ],
    "pattern": "(?:instead\\s+of|alternative\\s+to|replacement\\s+for|substitute\\s+for)\\s+(.+)",
    "template": {
      "like": "${1} alternative",
      "boost": "comparison"
    },
    "confidence": 0.88
  },
  {
    "id": "pros_cons",
    "category": "comparative",
    "examples": [
      "pros and cons of React",
      "advantages of Python",
      "benefits of AI"
    ],
    "pattern": "(?:pros\\s+and\\s+cons|advantages?|benefits?|disadvantages?)\\s+(?:of|for)\\s+(.+)",
    "template": {
      "like": "${1} analysis",
      "boost": "comparison"
    },
    "confidence": 0.86
  },
  {
    "id": "benchmark_performance",
    "category": "comparative",
    "examples": [
      "benchmark results",
      "performance comparison",
      "speed test"
    ],
    "pattern": "(?:benchmark|performance|speed\\s+test)\\s+(?:results?|comparison)?\\s*(?:for|of)?\\s*(.+)",
    "template": {
      "like": "${1} benchmark",
      "where": {
        "type": "benchmark"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "contextual_more_like",
    "category": "contextual",
    "examples": [
      "more like this",
      "similar papers",
      "find similar"
    ],
    "pattern": "(more like|similar to|like) (this|that|these)",
    "template": {
      "similar": "__context__"
    },
    "confidence": 0.8
  },
  {
    "id": "contextual_same_but",
    "category": "contextual",
    "examples": [
      "same but newer",
      "same query but from 2023"
    ],
    "pattern": "same (query |search |)but (.+)",
    "template": {
      "__modifier__": "${2}"
    },
    "confidence": 0.75
  },
  {
    "id": "conversational_need",
    "category": "conversational",
    "examples": [
      "I need help with Python",
      "I want to learn React",
      "I'm looking for AI papers"
    ],
    "pattern": "(?:I\\s+need|I\\s+want|I'm\\s+looking\\s+for)\\s+(.+)",
    "template": {
      "like": "${1}"
    },
    "confidence": 0.85
  },
  {
    "id": "conversational_can_you",
    "category": "conversational",
    "examples": [
      "can you find papers",
      "could you show me",
      "would you search for"
    ],
    "pattern": "(?:can|could|would)\\s+you\\s+(?:find|show|search|get)\\s+(?:me\\s+)?(.+)",
    "template": {
      "like": "${1}"
    },
    "confidence": 0.84
  },
  {
    "id": "industry_sector",
    "category": "domain",
    "examples": [
      "fintech applications",
      "healthcare AI",
      "education technology"
    ],
    "pattern": "(?:fintech|healthcare|education|finance|medical|legal|retail)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "industry": "${0}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "academic_citation",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "cite website APA",
      "MLA citation format",
      "Chicago style bibliography"
    ],
    "pattern": "(?:cite|citation)\\s+(.+?)\\s+(?:in\\s+)?(APA|MLA|Chicago|Harvard)",
    "template": {
      "like": "${1} citation ${2}",
      "where": {
        "domain": "academic",
        "type": "citation",
        "style": "${2}"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "academic_peer_reviewed",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "peer reviewed articles on climate change",
      "scholarly articles about AI"
    ],
    "pattern": "(?:peer\\s+reviewed|scholarly)\\s+(?:articles?|papers?)\\s+(?:on|about)\\s+(.+)",
    "template": {
      "like": "${1} peer reviewed",
      "where": {
        "domain": "academic",
        "type": "peer_reviewed"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "academic_journal_impact",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "Nature impact factor",
      "Science journal ranking",
      "PNAS impact factor"
    ],
    "pattern": "(.+?)\\s+(?:impact\\s+factor|journal\\s+ranking)",
    "template": {
      "like": "${1} impact factor",
      "where": {
        "domain": "academic",
        "type": "journal"
      }
    },
    "confidence": 0.92,
    "frequency": "medium"
  },
  {
    "id": "academic_publications",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "Einstein publications",
      "papers by Hinton",
      "Smith et al 2023"
    ],
    "pattern": "(?:(.+?)\\s+publications?|papers?\\s+by\\s+(.+))",
    "template": {
      "like": "${1}${2} publications",
      "where": {
        "domain": "academic",
        "type": "publication"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "academic_research_methodology",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "qualitative research methods",
      "sample size calculation",
      "statistical analysis"
    ],
    "pattern": "(.+?)\\s+(?:research\\s+methods?|methodology)",
    "template": {
      "like": "${1} methodology",
      "where": {
        "domain": "academic",
        "type": "methodology"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "academic_grant_funding",
    "category": "domain_specific",
    "domain": "academic",
    "examples": [
      "NSF grant opportunities",
      "research funding biology",
      "PhD funding"
    ],
    "pattern": "(.+?)\\s+(?:grant|funding)\\s*(?:opportunities)?",
    "template": {
      "like": "${1} funding",
      "where": {
        "domain": "academic",
        "type": "funding"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "ai_llm_models",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "ChatGPT API",
      "Claude vs GPT-4",
      "Llama 2 fine-tuning"
    ],
    "pattern": "(ChatGPT|Claude|GPT-4|Llama|Mistral|Gemini|DALL-E|Stable\\s+Diffusion)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "ai",
        "type": "llm"
      }
    },
    "confidence": 0.95,
    "frequency": "very_high"
  },
  {
    "id": "ai_dataset",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "MNIST dataset",
      "ImageNet download",
      "COCO dataset"
    ],
    "pattern": "(MNIST|ImageNet|COCO|CIFAR|WikiText|GLUE|SQuAD)\\s*(?:dataset)?\\s*(.+)?",
    "template": {
      "like": "${1} dataset ${2}",
      "where": {
        "domain": "ai",
        "type": "dataset"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "ai_pretrained_model",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "BERT pretrained model",
      "download GPT-2",
      "use ResNet50"
    ],
    "pattern": "(BERT|GPT|GPT-2|GPT-3|GPT-4|ResNet|VGG|YOLO|EfficientNet)\\s+(?:pretrained\\s+)?(?:model)?\\s*(.+)?",
    "template": {
      "like": "${1} pretrained ${2}",
      "where": {
        "domain": "ai",
        "type": "pretrained_model"
      }
    },
    "confidence": 0.94,
    "frequency": "very_high"
  },
  {
    "id": "ai_model_training",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "train BERT model",
      "fine-tune GPT",
      "train neural network"
    ],
    "pattern": "(?:train|fine-?tune)\\s+(.+?)\\s*(?:model|network)?",
    "template": {
      "like": "train ${1}",
      "where": {
        "domain": "ai",
        "type": "training"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "ai_framework_comparison",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "TensorFlow vs PyTorch",
      "Keras or TensorFlow",
      "JAX vs PyTorch"
    ],
    "pattern": "(TensorFlow|PyTorch|Keras|JAX|MXNet|Caffe|Theano)\\s+(?:vs\\.?|or)\\s+(.+)",
    "template": {
      "like": "${1} vs ${2}",
      "where": {
        "domain": "ai",
        "type": "framework_comparison"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "ai_prompt_engineering",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "prompt engineering tips",
      "ChatGPT prompts",
      "system prompt examples"
    ],
    "pattern": "(?:prompt\\s+engineering|prompts?|system\\s+prompt)\\s+(.+)",
    "template": {
      "like": "prompt engineering ${1}",
      "where": {
        "domain": "ai",
        "type": "prompt_engineering"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "ai_machine_learning",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "random forest sklearn",
      "neural network PyTorch",
      "CNN TensorFlow"
    ],
    "pattern": "(random\\s+forest|neural\\s+network|CNN|RNN|LSTM|transformer|SVM|k-?means)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "ai",
        "type": "ml_algorithm"
      }
    },
    "confidence": 0.92,
    "frequency": "very_high"
  },
  {
    "id": "ai_nlp_task",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "sentiment analysis Python",
      "named entity recognition",
      "text classification BERT"
    ],
    "pattern": "(sentiment\\s+analysis|NER|named\\s+entity|text\\s+classification|summarization|translation)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "ai",
        "type": "nlp"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "ai_metrics",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "accuracy vs precision",
      "F1 score calculation",
      "ROC curve explained"
    ],
    "pattern": "(accuracy|precision|recall|F1\\s+score|ROC|AUC|loss|perplexity)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "ai",
        "type": "metrics"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "ai_computer_vision",
    "category": "domain_specific",
    "domain": "ai",
    "examples": [
      "object detection YOLO",
      "image segmentation",
      "face recognition OpenCV"
    ],
    "pattern": "(object\\s+detection|image\\s+segmentation|face\\s+recognition|OCR|image\\s+classification)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "ai",
        "type": "computer_vision"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "ecommerce_reviews",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "iPhone 15 reviews",
      "best laptop reviews",
      "Samsung TV ratings"
    ],
    "pattern": "(.+?)\\s+(?:reviews?|ratings?)",
    "template": {
      "like": "${1} reviews",
      "where": {
        "domain": "ecommerce",
        "type": "review"
      }
    },
    "confidence": 0.95,
    "frequency": "high"
  },
  {
    "id": "ecommerce_price_comparison",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "cheapest PS5",
      "best price MacBook",
      "lowest price Nike shoes"
    ],
    "pattern": "(?:cheapest|best\\s+price|lowest\\s+price)\\s+(.+)",
    "template": {
      "like": "${1} price",
      "where": {
        "domain": "ecommerce",
        "sort": "price_asc"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "ecommerce_deals",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "Amazon deals today",
      "Black Friday sales",
      "coupon codes Target"
    ],
    "pattern": "(.+?)\\s+(?:deals?|sales?|coupon\\s+codes?)\\s*(?:today)?",
    "template": {
      "like": "${1} deals",
      "where": {
        "domain": "ecommerce",
        "type": "deals"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "ecommerce_in_stock",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "PS5 in stock",
      "RTX 4090 availability",
      "iPhone 15 where to buy"
    ],
    "pattern": "(.+?)\\s+(?:in\\s+stock|availability|where\\s+to\\s+buy)",
    "template": {
      "like": "${1} availability",
      "where": {
        "domain": "ecommerce",
        "in_stock": true
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "ecommerce_size_chart",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "Nike size chart",
      "ring size guide",
      "clothing size conversion"
    ],
    "pattern": "(.+?)\\s+size\\s+(?:chart|guide|conversion)",
    "template": {
      "like": "${1} size chart",
      "where": {
        "domain": "ecommerce",
        "type": "sizing"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "ecommerce_return_policy",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "Amazon return policy",
      "Walmart refund",
      "exchange policy Best Buy"
    ],
    "pattern": "(.+?)\\s+(?:return\\s+policy|refund|exchange)",
    "template": {
      "like": "${1} return policy",
      "where": {
        "domain": "ecommerce",
        "type": "policy"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "ecommerce_warranty",
    "category": "domain_specific",
    "domain": "ecommerce",
    "examples": [
      "Apple warranty check",
      "extended warranty worth it",
      "warranty claim Samsung"
    ],
    "pattern": "(.+?)\\s+warranty\\s*(.+)?",
    "template": {
      "like": "${1} warranty ${2}",
      "where": {
        "domain": "ecommerce",
        "type": "warranty"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "financial_stock_price",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "AAPL stock price",
      "Tesla share price",
      "GOOGL quote"
    ],
    "pattern": "([A-Z]{1,5})\\s+(?:stock\\s+)?(?:price|quote|shares?)",
    "template": {
      "like": "${1} stock price",
      "where": {
        "domain": "financial",
        "type": "stock",
        "ticker": "${1}"
      }
    },
    "confidence": 0.95,
    "frequency": "high"
  },
  {
    "id": "financial_calculator",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "mortgage calculator",
      "loan payment calculator",
      "retirement calculator"
    ],
    "pattern": "(.+?)\\s+calculator",
    "template": {
      "like": "${1} calculator",
      "where": {
        "domain": "financial",
        "type": "calculator"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "financial_interest_rates",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "mortgage interest rates",
      "CD rates today",
      "Fed interest rate"
    ],
    "pattern": "(.+?)\\s+(?:interest\\s+)?rates?\\s*(?:today|current)?",
    "template": {
      "like": "${1} interest rates",
      "where": {
        "domain": "financial",
        "type": "rates"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "financial_credit_score",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "credit score for mortgage",
      "improve credit score",
      "free credit report"
    ],
    "pattern": "(?:credit\\s+score|credit\\s+report)\\s+(?:for\\s+)?(.+)?",
    "template": {
      "like": "credit score ${1}",
      "where": {
        "domain": "financial",
        "type": "credit"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "financial_tax",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "tax deductions for homeowners",
      "capital gains tax rate",
      "tax brackets 2024"
    ],
    "pattern": "tax\\s+(.+?)\\s+(?:for\\s+(.+)|rate|brackets?)",
    "template": {
      "like": "tax ${1} ${2}",
      "where": {
        "domain": "financial",
        "type": "tax"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "financial_crypto",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "Bitcoin price",
      "Ethereum forecast",
      "buy cryptocurrency"
    ],
    "pattern": "(.+?)\\s+(?:price|forecast|buy|sell)",
    "template": {
      "like": "${1} cryptocurrency",
      "where": {
        "domain": "financial",
        "type": "crypto"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "financial_investment_strategy",
    "category": "domain_specific",
    "domain": "financial",
    "examples": [
      "401k investment strategy",
      "best ETFs 2024",
      "dividend investing"
    ],
    "pattern": "(.+?)\\s+(?:investment\\s+strategy|investing)",
    "template": {
      "like": "${1} investment strategy",
      "where": {
        "domain": "financial",
        "type": "investment"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "legal_statute_limitations",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "statute of limitations personal injury",
      "SOL for debt collection"
    ],
    "pattern": "statute\\s+of\\s+limitations?\\s+(?:for\\s+)?(.+)",
    "template": {
      "like": "${1} statute of limitations",
      "where": {
        "domain": "legal",
        "type": "statute"
      }
    },
    "confidence": 0.93,
    "frequency": "medium"
  },
  {
    "id": "legal_lawyer_type",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "divorce lawyer near me",
      "personal injury attorney",
      "criminal defense lawyer"
    ],
    "pattern": "(.+?)\\s+(?:lawyer|attorney)\\s*(?:near\\s+me)?",
    "template": {
      "like": "${1} lawyer",
      "where": {
        "domain": "legal",
        "type": "attorney"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "legal_how_to_file",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "how to file bankruptcy",
      "file for divorce",
      "file a complaint"
    ],
    "pattern": "(?:how\\s+to\\s+)?file\\s+(?:for\\s+)?(.+)",
    "template": {
      "like": "file ${1} procedure",
      "where": {
        "domain": "legal",
        "type": "filing"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "legal_jurisdiction",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "marijuana laws in California",
      "gun laws by state",
      "divorce laws in Texas"
    ],
    "pattern": "(.+?)\\s+laws?\\s+(?:in|by)\\s+(.+)",
    "template": {
      "like": "${1} laws ${2}",
      "where": {
        "domain": "legal",
        "jurisdiction": "${2}"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "legal_contract_template",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "rental agreement template",
      "NDA template",
      "employment contract sample"
    ],
    "pattern": "(.+?)\\s+(?:template|sample|form)",
    "template": {
      "like": "${1} template",
      "where": {
        "domain": "legal",
        "type": "template"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "legal_definition",
    "category": "domain_specific",
    "domain": "legal",
    "examples": [
      "tort law definition",
      "what is habeas corpus",
      "felony vs misdemeanor"
    ],
    "pattern": "(?:what\\s+is\\s+)?(.+?)\\s+(?:definition|meaning|vs\\.?\\s+(.+))",
    "template": {
      "like": "${1} ${2} legal definition",
      "where": {
        "domain": "legal",
        "type": "definition"
      }
    },
    "confidence": 0.9,
    "frequency": "high"
  },
  {
    "id": "medical_symptoms",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "symptoms of COVID",
      "symptoms of diabetes",
      "signs of heart attack"
    ],
    "pattern": "(?:symptoms?|signs?)\\s+(?:of|for)\\s+(.+)",
    "template": {
      "like": "${1} symptoms",
      "where": {
        "domain": "medical",
        "type": "symptoms"
      }
    },
    "confidence": 0.95,
    "frequency": "high"
  },
  {
    "id": "medical_side_effects",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "aspirin side effects",
      "vaccine side effects",
      "metformin side effects"
    ],
    "pattern": "(.+?)\\s+side\\s+effects?",
    "template": {
      "like": "${1} side effects",
      "where": {
        "domain": "medical",
        "type": "medication"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "medical_treatment",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "treatment for depression",
      "cure for cancer",
      "therapy for anxiety"
    ],
    "pattern": "(?:treatment|cure|therapy|remedy)\\s+(?:for|of)\\s+(.+)",
    "template": {
      "like": "${1} treatment",
      "where": {
        "domain": "medical",
        "type": "treatment"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "medical_pain",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "chest pain causes",
      "back pain relief",
      "headache remedies"
    ],
    "pattern": "(.+?)\\s+pain\\s+(?:causes?|relief|remedies?)",
    "template": {
      "like": "${1} pain",
      "where": {
        "domain": "medical",
        "type": "pain"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "medical_vaccine",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "COVID vaccine side effects",
      "flu shot effectiveness",
      "vaccine schedule babies"
    ],
    "pattern": "(.+?)\\s+vaccine\\s+(.+)",
    "template": {
      "like": "${1} vaccine ${2}",
      "where": {
        "domain": "medical",
        "type": "vaccine"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "medical_test_results",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "blood test results",
      "MRI results meaning",
      "normal cholesterol levels"
    ],
    "pattern": "(?:(.+?)\\s+)?(?:test\\s+)?results?\\s+(?:meaning|interpretation|normal\\s+range)",
    "template": {
      "like": "${1} test results",
      "where": {
        "domain": "medical",
        "type": "diagnostic"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "medical_doctor_specialist",
    "category": "domain_specific",
    "domain": "medical",
    "examples": [
      "cardiologist near me",
      "best dermatologist",
      "pediatrician reviews"
    ],
    "pattern": "(.+?(?:ologist|ician|doctor))\\s+(?:near\\s+me|reviews?|best)",
    "template": {
      "like": "${1}",
      "where": {
        "domain": "medical",
        "type": "specialist"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "prog_error_message",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "TypeError cannot read property",
      "undefined is not a function",
      "NullPointerException Java"
    ],
    "pattern": "([A-Za-z]+Error|[A-Za-z]+Exception)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "programming",
        "type": "error"
      }
    },
    "confidence": 0.96,
    "frequency": "very_high"
  },
  {
    "id": "prog_how_to_code",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "how to reverse string Python",
      "sort array JavaScript",
      "read file in Java"
    ],
    "pattern": "(?:how\\s+to\\s+)?(.+?)\\s+(?:in|using)\\s+(Python|JavaScript|Java|C\\+\\+|TypeScript|Go|Rust|Ruby|PHP|Swift|Kotlin|C#)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "programming",
        "language": "${2}"
      }
    },
    "confidence": 0.95,
    "frequency": "very_high"
  },
  {
    "id": "prog_git_commands",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "git merge conflict",
      "git rebase vs merge",
      "git undo commit"
    ],
    "pattern": "git\\s+(.+)",
    "template": {
      "like": "git ${1}",
      "where": {
        "domain": "programming",
        "type": "version_control"
      }
    },
    "confidence": 0.95,
    "frequency": "very_high"
  },
  {
    "id": "prog_stackoverflow_pattern",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "undefined is not a function JavaScript",
      "cannot read property of undefined React"
    ],
    "pattern": "(.+?)\\s+(JavaScript|Python|Java|C\\+\\+|React|Angular|Vue)$",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "programming",
        "source": "stackoverflow"
      }
    },
    "confidence": 0.95,
    "frequency": "very_high"
  },
  {
    "id": "prog_install_package",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "npm install react",
      "pip install tensorflow",
      "cargo add tokio"
    ],
    "pattern": "(?:npm|pip|yarn|cargo|gem|composer|go get|brew|apt|yum)\\s+(?:install|add|get)\\s+(.+)",
    "template": {
      "like": "install ${1}",
      "where": {
        "domain": "programming",
        "type": "package_install"
      }
    },
    "confidence": 0.94,
    "frequency": "very_high"
  },
  {
    "id": "prog_framework_tutorial",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "React tutorial",
      "Django getting started",
      "Spring Boot guide"
    ],
    "pattern": "(React|Vue|Angular|Django|Flask|Spring|Express|Rails|Laravel|Next\\.js|Nuxt|FastAPI)\\s+(?:tutorial|guide|getting\\s+started)",
    "template": {
      "like": "${1} tutorial",
      "where": {
        "domain": "programming",
        "framework": "${1}"
      }
    },
    "confidence": 0.94,
    "frequency": "very_high"
  },
  {
    "id": "prog_debug_issue",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "debug React hooks",
      "memory leak Java",
      "segmentation fault C++"
    ],
    "pattern": "(?:debug|fix|solve|troubleshoot)\\s+(.+?)\\s*(?:issue|problem|error|bug)?",
    "template": {
      "like": "debug ${1}",
      "where": {
        "domain": "programming",
        "type": "debugging"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "prog_api_docs",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "OpenAI API documentation",
      "Stripe API reference",
      "REST API example"
    ],
    "pattern": "(.+?)\\s+API\\s+(?:documentation|reference|example|tutorial)",
    "template": {
      "like": "${1} API documentation",
      "where": {
        "domain": "programming",
        "type": "api"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "prog_import_module",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "import React from react",
      "from sklearn import",
      "require module Node.js"
    ],
    "pattern": "(?:import|from|require|use|include)\\s+(.+?)\\s+(?:from|in)?\\s*(.+)?",
    "template": {
      "like": "import ${1} ${2}",
      "where": {
        "domain": "programming",
        "type": "import"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "prog_algorithm",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "quicksort algorithm",
      "binary search implementation",
      "Dijkstra's algorithm"
    ],
    "pattern": "(.+?)\\s+(?:algorithm|implementation)\\s*(?:in\\s+(.+))?",
    "template": {
      "like": "${1} algorithm ${2}",
      "where": {
        "domain": "programming",
        "type": "algorithm"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "prog_best_practices",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "React best practices",
      "Python coding standards",
      "clean code JavaScript"
    ],
    "pattern": "(.+?)\\s+(?:best\\s+practices?|coding\\s+standards?|clean\\s+code|style\\s+guide)",
    "template": {
      "like": "${1} best practices",
      "where": {
        "domain": "programming",
        "type": "best_practices"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "prog_regex_pattern",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "regex email validation",
      "regular expression phone number",
      "regex match URL"
    ],
    "pattern": "(?:regex|regular\\s+expression)\\s+(?:for\\s+)?(.+)",
    "template": {
      "like": "regex ${1}",
      "where": {
        "domain": "programming",
        "type": "regex"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "prog_convert_code",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "convert Python to JavaScript",
      "JSON to XML",
      "SQL to MongoDB"
    ],
    "pattern": "(?:convert|translate|transform)\\s+(.+?)\\s+to\\s+(.+)",
    "template": {
      "like": "convert ${1} to ${2}",
      "where": {
        "domain": "programming",
        "type": "conversion"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "prog_data_structure",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "linked list vs array",
      "implement stack Python",
      "binary tree traversal"
    ],
    "pattern": "(?:implement\\s+)?(.+?)\\s*(?:data\\s+structure|vs\\.?\\s+(.+))?\\s*(?:in\\s+(.+))?",
    "template": {
      "like": "${1} data structure ${2} ${3}",
      "where": {
        "domain": "programming",
        "type": "data_structure"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "prog_vscode_extension",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "VSCode extension Python",
      "best VSCode themes",
      "VSCode shortcuts"
    ],
    "pattern": "(?:VSCode|VS\\s+Code)\\s+(.+)",
    "template": {
      "like": "VSCode ${1}",
      "where": {
        "domain": "programming",
        "type": "ide"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "prog_package_version",
    "category": "domain_specific",
    "domain": "programming",
    "examples": [
      "React 18 features",
      "Python 3.11 new",
      "Node.js version 20"
    ],
    "pattern": "(.+?)\\s+(?:version\\s+)?(\\d+(?:\\.\\d+)*)\\s*(.+)?",
    "template": {
      "like": "${1} ${2} ${3}",
      "where": {
        "domain": "programming",
        "version": "${2}"
      }
    },
    "confidence": 0.9,
    "frequency": "high"
  },
  {
    "id": "social_trending",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "trending on Twitter",
      "viral TikTok videos",
      "Instagram trends 2024"
    ],
    "pattern": "(?:trending|viral|popular)\\s+(?:on\\s+)?(Twitter|TikTok|Instagram|YouTube|LinkedIn|Reddit|Facebook)\\s*(.+)?",
    "template": {
      "like": "${1} trending ${2}",
      "where": {
        "domain": "social",
        "platform": "${1}",
        "type": "trending"
      }
    },
    "confidence": 0.94,
    "frequency": "very_high"
  },
  {
    "id": "social_algorithm",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram algorithm 2024",
      "TikTok algorithm explained",
      "YouTube algorithm changes"
    ],
    "pattern": "(Instagram|TikTok|YouTube|Twitter|LinkedIn)\\s+algorithm\\s*(.+)?",
    "template": {
      "like": "${1} algorithm ${2}",
      "where": {
        "domain": "social",
        "platform": "${1}",
        "type": "algorithm"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "social_followers",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "how to get more followers",
      "increase Instagram followers",
      "buy Twitter followers"
    ],
    "pattern": "(?:how\\s+to\\s+)?(?:get|gain|increase|buy)\\s+(?:more\\s+)?(.+?)\\s+followers?",
    "template": {
      "like": "${1} followers growth",
      "where": {
        "domain": "social",
        "type": "growth"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "social_monetization",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "monetize Instagram",
      "YouTube earnings calculator",
      "TikTok creator fund"
    ],
    "pattern": "(?:monetize|earn\\s+money|creator\\s+fund)\\s+(?:on\\s+)?(.+)",
    "template": {
      "like": "monetize ${1}",
      "where": {
        "domain": "social",
        "type": "monetization"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "social_hashtag",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "#AI hashtag",
      "best hashtags for Instagram",
      "trending hashtags today"
    ],
    "pattern": "(?:#(\\w+)|hashtags?\\s+(?:for\\s+)?(.+))",
    "template": {
      "like": "hashtag ${1}${2}",
      "where": {
        "domain": "social",
        "type": "hashtag"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "social_content_ideas",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram post ideas",
      "TikTok video ideas",
      "LinkedIn content strategy"
    ],
    "pattern": "(.+?)\\s+(?:post|video|content|story)\\s+(?:ideas?|strategy|tips?)",
    "template": {
      "like": "${1} content ideas",
      "where": {
        "domain": "social",
        "type": "content_strategy"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "social_caption",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram caption ideas",
      "funny captions",
      "caption for selfie"
    ],
    "pattern": "(.+?)\\s*(?:captions?|quotes?)\\s+(?:for\\s+)?(.+)?",
    "template": {
      "like": "${1} caption ${2}",
      "where": {
        "domain": "social",
        "type": "caption"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "social_verification",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "get verified on Instagram",
      "Twitter blue checkmark",
      "verification requirements"
    ],
    "pattern": "(?:get\\s+)?verifi(?:ed|cation)\\s+(?:on\\s+)?(.+)",
    "template": {
      "like": "${1} verification",
      "where": {
        "domain": "social",
        "type": "verification"
      }
    },
    "confidence": 0.92,
    "frequency": "medium"
  },
  {
    "id": "social_influencer",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "top tech influencers",
      "Instagram influencers fashion",
      "YouTube creators gaming"
    ],
    "pattern": "(?:top\\s+)?(.+?)\\s+(?:influencers?|creators?|YouTubers?)\\s*(?:on\\s+(.+))?",
    "template": {
      "like": "${1} influencers ${2}",
      "where": {
        "domain": "social",
        "type": "influencer"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "social_analytics",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram analytics tools",
      "track Twitter engagement",
      "social media metrics"
    ],
    "pattern": "(.+?)\\s+(?:analytics?|metrics?|insights?|engagement)\\s*(?:tools?)?",
    "template": {
      "like": "${1} analytics",
      "where": {
        "domain": "social",
        "type": "analytics"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "social_bio_profile",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram bio ideas",
      "LinkedIn profile tips",
      "Twitter bio generator"
    ],
    "pattern": "(.+?)\\s+(?:bio|profile)\\s+(?:ideas?|tips?|generator|examples?)",
    "template": {
      "like": "${1} bio ideas",
      "where": {
        "domain": "social",
        "type": "profile"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "social_story_reel",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram story ideas",
      "how to make reels",
      "TikTok vs Reels"
    ],
    "pattern": "(?:Instagram\\s+)?(?:story|stories|reels?)\\s+(.+)",
    "template": {
      "like": "story reels ${1}",
      "where": {
        "domain": "social",
        "type": "stories"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "social_privacy_settings",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram privacy settings",
      "make Twitter private",
      "Facebook privacy"
    ],
    "pattern": "(.+?)\\s+privacy\\s*(?:settings?)?",
    "template": {
      "like": "${1} privacy",
      "where": {
        "domain": "social",
        "type": "privacy"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "social_scheduling",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "best time to post Instagram",
      "schedule tweets",
      "social media calendar"
    ],
    "pattern": "(?:best\\s+time\\s+to\\s+post|schedule)\\s+(.+)",
    "template": {
      "like": "${1} posting schedule",
      "where": {
        "domain": "social",
        "type": "scheduling"
      }
    },
    "confidence": 0.9,
    "frequency": "high"
  },
  {
    "id": "social_collaboration",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram collaboration",
      "brand partnerships",
      "influencer marketing"
    ],
    "pattern": "(?:brand\\s+)?(?:collaboration|partnership|sponsorship)\\s+(.+)",
    "template": {
      "like": "${1} collaboration",
      "where": {
        "domain": "social",
        "type": "collaboration"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "social_live_streaming",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram live tips",
      "YouTube streaming setup",
      "Twitch vs YouTube"
    ],
    "pattern": "(.+?)\\s+(?:live|streaming|stream)\\s*(.+)?",
    "template": {
      "like": "${1} live streaming ${2}",
      "where": {
        "domain": "social",
        "type": "streaming"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "social_username",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "username ideas aesthetic",
      "check username availability",
      "Instagram username generator"
    ],
    "pattern": "(?:username|handle)\\s+(.+)",
    "template": {
      "like": "username ${1}",
      "where": {
        "domain": "social",
        "type": "username"
      }
    },
    "confidence": 0.89,
    "frequency": "medium"
  },
  {
    "id": "social_dm_messaging",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram DM not working",
      "Twitter DM limits",
      "LinkedIn message templates"
    ],
    "pattern": "(.+?)\\s+(?:DM|direct\\s+message|messaging)\\s*(.+)?",
    "template": {
      "like": "${1} messaging ${2}",
      "where": {
        "domain": "social",
        "type": "messaging"
      }
    },
    "confidence": 0.89,
    "frequency": "medium"
  },
  {
    "id": "social_meme_viral",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "trending memes",
      "meme generator",
      "viral video ideas"
    ],
    "pattern": "(?:trending\\s+)?(?:memes?|viral\\s+videos?)\\s*(.+)?",
    "template": {
      "like": "memes viral ${1}",
      "where": {
        "domain": "social",
        "type": "meme"
      }
    },
    "confidence": 0.89,
    "frequency": "high"
  },
  {
    "id": "social_filters_effects",
    "category": "domain_specific",
    "domain": "social",
    "examples": [
      "Instagram filters",
      "TikTok effects",
      "Snapchat lenses"
    ],
    "pattern": "(.+?)\\s+(?:filters?|effects?|lenses?)\\s*(.+)?",
    "template": {
      "like": "${1} filters ${2}",
      "where": {
        "domain": "social",
        "type": "filters"
      }
    },
    "confidence": 0.88,
    "frequency": "medium"
  },
  {
    "id": "tech_database_query",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "SQL join example",
      "MongoDB aggregation",
      "PostgreSQL vs MySQL"
    ],
    "pattern": "(SQL|MySQL|PostgreSQL|MongoDB|Redis|Elasticsearch|Cassandra)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "database"
      }
    },
    "confidence": 0.94,
    "frequency": "very_high"
  },
  {
    "id": "tech_cloud_service",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "AWS S3 tutorial",
      "Google Cloud pricing",
      "Azure vs AWS"
    ],
    "pattern": "(AWS|Azure|GCP|Google\\s+Cloud|Heroku|DigitalOcean|Vercel|Netlify)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "cloud"
      }
    },
    "confidence": 0.93,
    "frequency": "very_high"
  },
  {
    "id": "tech_security",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "SQL injection prevention",
      "XSS attack",
      "JWT authentication"
    ],
    "pattern": "(SQL\\s+injection|XSS|CSRF|JWT|OAuth|authentication|authorization)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "security"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "tech_docker_kubernetes",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "Docker compose example",
      "Kubernetes deployment",
      "dockerfile for Node.js"
    ],
    "pattern": "(Docker|Kubernetes|K8s|container|dockerfile|docker-compose)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "containerization"
      }
    },
    "confidence": 0.92,
    "frequency": "very_high"
  },
  {
    "id": "tech_performance",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "optimize React performance",
      "database indexing",
      "lazy loading implementation"
    ],
    "pattern": "(?:optimize|improve)\\s+(.+?)\\s+performance",
    "template": {
      "like": "${1} performance optimization",
      "where": {
        "domain": "tech",
        "type": "performance"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "tech_web_framework",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "Next.js vs Gatsby",
      "Tailwind CSS tutorial",
      "Bootstrap components"
    ],
    "pattern": "(Next\\.js|Gatsby|Tailwind|Bootstrap|Material-UI|Chakra|Ant\\s+Design)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "web_framework"
      }
    },
    "confidence": 0.92,
    "frequency": "very_high"
  },
  {
    "id": "tech_cli_commands",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "curl POST request",
      "wget download file",
      "ssh key generation"
    ],
    "pattern": "(curl|wget|ssh|scp|rsync|grep|sed|awk|chmod|chown)\\s+(.+)",
    "template": {
      "like": "${1} command ${2}",
      "where": {
        "domain": "tech",
        "type": "cli"
      }
    },
    "confidence": 0.92,
    "frequency": "very_high"
  },
  {
    "id": "tech_devops_ci_cd",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "GitHub Actions workflow",
      "Jenkins pipeline",
      "CI/CD best practices"
    ],
    "pattern": "(GitHub\\s+Actions|Jenkins|CircleCI|Travis|GitLab\\s+CI|CI/CD)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "devops"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "tech_testing",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "unit testing Jest",
      "integration testing",
      "mock API calls"
    ],
    "pattern": "(unit\\s+test|integration\\s+test|e2e\\s+test|mock|stub)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "testing"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "tech_mobile_dev",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "React Native navigation",
      "Flutter vs React Native",
      "SwiftUI tutorial"
    ],
    "pattern": "(React\\s+Native|Flutter|SwiftUI|Kotlin|Swift|Android|iOS)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "mobile"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "tech_linux_admin",
    "category": "domain_specific",
    "domain": "tech",
    "examples": [
      "Ubuntu install package",
      "systemd service",
      "cron job example"
    ],
    "pattern": "(Ubuntu|Debian|CentOS|Linux|systemd|cron|iptables|nginx|apache)\\s+(.+)",
    "template": {
      "like": "${1} ${2}",
      "where": {
        "domain": "tech",
        "type": "sysadmin"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "technical_error_fix",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "error 404 fix",
      "blue screen of death",
      "kernel panic solution"
    ],
    "pattern": "(?:error\\s+)?(.+?)\\s+(?:fix|solution|resolve)",
    "template": {
      "like": "${1} fix",
      "where": {
        "domain": "technical",
        "type": "troubleshooting"
      }
    },
    "confidence": 0.94,
    "frequency": "high"
  },
  {
    "id": "technical_not_working",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "WiFi not working",
      "printer not responding",
      "app won't open"
    ],
    "pattern": "(.+?)\\s+(?:not\\s+working|won't\\s+(?:open|start|load)|not\\s+responding)",
    "template": {
      "like": "${1} troubleshooting",
      "where": {
        "domain": "technical",
        "type": "issue"
      }
    },
    "confidence": 0.93,
    "frequency": "high"
  },
  {
    "id": "technical_driver_download",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "NVIDIA driver download",
      "printer driver HP",
      "Realtek audio driver"
    ],
    "pattern": "(.+?)\\s+driver\\s*(?:download)?",
    "template": {
      "like": "${1} driver",
      "where": {
        "domain": "technical",
        "type": "driver"
      }
    },
    "confidence": 0.93,
    "frequency": "medium"
  },
  {
    "id": "technical_how_to_reset",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "reset iPhone",
      "factory reset laptop",
      "reset password Windows"
    ],
    "pattern": "(?:how\\s+to\\s+)?(?:reset|factory\\s+reset)\\s+(.+)",
    "template": {
      "like": "reset ${1}",
      "where": {
        "domain": "technical",
        "type": "reset"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "technical_backup_restore",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "backup iPhone",
      "restore from backup",
      "cloud backup options"
    ],
    "pattern": "(?:backup|restore)\\s+(?:from\\s+)?(.+)",
    "template": {
      "like": "${1} backup",
      "where": {
        "domain": "technical",
        "type": "backup"
      }
    },
    "confidence": 0.92,
    "frequency": "high"
  },
  {
    "id": "technical_update",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "update Windows 11",
      "iOS 17 update",
      "Chrome latest version"
    ],
    "pattern": "(?:update|upgrade)\\s+(.+?)\\s*(?:to\\s+(.+))?",
    "template": {
      "like": "${1} update ${2}",
      "where": {
        "domain": "technical",
        "type": "update"
      }
    },
    "confidence": 0.91,
    "frequency": "high"
  },
  {
    "id": "technical_compatibility",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "compatible with Windows 11",
      "works with Mac",
      "supports Android"
    ],
    "pattern": "(?:compatible\\s+with|works\\s+with|supports?)\\s+(.+)",
    "template": {
      "like": "${1} compatibility",
      "where": {
        "domain": "technical",
        "type": "compatibility"
      }
    },
    "confidence": 0.91,
    "frequency": "medium"
  },
  {
    "id": "technical_speed_up",
    "category": "domain_specific",
    "domain": "technical",
    "examples": [
      "speed up computer",
      "make phone faster",
      "optimize Windows"
    ],
    "pattern": "(?:speed\\s+up|make\\s+(.+?)\\s+faster|optimize)\\s+(.+)",
    "template": {
      "like": "${1}${2} optimization",
      "where": {
        "domain": "technical",
        "type": "performance"
      }
    },
    "confidence": 0.9,
    "frequency": "medium"
  },
  {
    "id": "is_there_any",
    "category": "existence",
    "examples": [
      "is there any research on",
      "are there any papers about"
    ],
    "pattern": "(?:is|are)\\s+there\\s+(?:any\\s+)?(.+?)\\s+(?:on|about|for)\\s+(.+)",
    "template": {
      "like": "${2} ${1}"
    },
    "confidence": 0.83
  },
  {
    "id": "filter_more_than",
    "category": "filtering",
    "examples": [
      "papers with more than 100 citations",
      "models with over 1B parameters"
    ],
    "pattern": "(.+) with (more than|over|greater than) (\\d+) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${4}": {
          "greaterThan": "${3}"
        }
      }
    },
    "confidence": 0.9
  },
  {
    "id": "filter_less_than",
    "category": "filtering",
    "examples": [
      "models with less than 1M parameters",
      "papers with under 10 citations"
    ],
    "pattern": "(.+) with (less than|under|fewer than) (\\d+) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${4}": {
          "lessThan": "${3}"
        }
      }
    },
    "confidence": 0.9
  },
  {
    "id": "all_that_have",
    "category": "filtering",
    "examples": [
      "all papers that have citations",
      "all documents that contain"
    ],
    "pattern": "all\\s+(.+?)\\s+that\\s+(?:have|contain|include)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${2}": {
          "exists": true
        }
      }
    },
    "confidence": 0.86
  },
  {
    "id": "filter_with",
    "category": "filtering",
    "examples": [
      "papers with code",
      "models with pretrained weights",
      "datasets with labels"
    ],
    "pattern": "(.+) with (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${2}": {
          "exists": true
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "filter_without",
    "category": "filtering",
    "examples": [
      "papers without code",
      "models without training",
      "datasets without labels"
    ],
    "pattern": "(.+) without (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${2}": {
          "exists": false
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "filter_except",
    "category": "filtering",
    "examples": [
      "all models except GPT",
      "papers except reviews",
      "everything but tutorials"
    ],
    "pattern": "(.+) (except|but not|excluding) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "notLike": "${3}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "filter_including",
    "category": "filtering",
    "examples": [
      "papers including code",
      "models including documentation"
    ],
    "pattern": "(.+) (including|with|containing) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "includes": "${3}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "filter_exactly",
    "category": "filtering",
    "examples": [
      "papers with exactly 5 authors",
      "models with 12 layers"
    ],
    "pattern": "(.+) with (exactly |)(\\d+) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${4}": "${3}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "with_without",
    "category": "filtering",
    "examples": [
      "papers with citations",
      "results without errors",
      "documents with images"
    ],
    "pattern": "(.+?)\\s+(with|without)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "${3}": {
          "exists": true
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "starting_with",
    "category": "filtering",
    "examples": [
      "starting with A",
      "beginning with chapter",
      "ending with PDF"
    ],
    "pattern": "(.+?)\\s+(?:starting|beginning|ending)\\s+with\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "pattern": "${2}"
      }
    },
    "confidence": 0.84
  },
  {
    "id": "filter_only",
    "category": "filtering",
    "examples": [
      "only open source models",
      "only free datasets",
      "papers only"
    ],
    "pattern": "(only )? (.+) (only)?",
    "template": {
      "like": "${2}",
      "where": {
        "exclusive": true
      }
    },
    "confidence": 0.75
  },
  {
    "id": "documentation_for",
    "category": "informational",
    "examples": [
      "documentation for React",
      "docs on Python",
      "API reference"
    ],
    "pattern": "(?:documentation|docs|reference|manual)\\s+(?:for|on|about)?\\s*(.+)",
    "template": {
      "like": "${1} documentation",
      "where": {
        "type": "documentation"
      }
    },
    "confidence": 0.93
  },
  {
    "id": "tutorial_howto",
    "category": "informational",
    "examples": [
      "tutorial on machine learning",
      "guide to Python",
      "how to use React"
    ],
    "pattern": "(?:tutorial|guide|how\\s+to\\s+use)\\s+(?:on|to|for)?\\s*(.+)",
    "template": {
      "like": "${1} tutorial",
      "boost": "educational"
    },
    "confidence": 0.92
  },
  {
    "id": "getting_started",
    "category": "informational",
    "examples": [
      "getting started with React",
      "introduction to Python",
      "beginner guide"
    ],
    "pattern": "(?:getting\\s+started|introduction|beginner'?s?\\s+guide)\\s+(?:with|to|for)?\\s*(.+)",
    "template": {
      "like": "${1} beginner",
      "boost": "educational"
    },
    "confidence": 0.92
  },
  {
    "id": "definition_of",
    "category": "informational",
    "examples": [
      "definition of AI",
      "what does ML mean",
      "meaning of neural network"
    ],
    "pattern": "(?:definition\\s+of|what\\s+does\\s+(.+?)\\s+mean|meaning\\s+of)\\s*(.+)",
    "template": {
      "like": "${1}${2} definition",
      "boost": "educational"
    },
    "confidence": 0.91
  },
  {
    "id": "cheat_sheet",
    "category": "informational",
    "examples": [
      "cheat sheet for Python",
      "quick reference",
      "cheatsheet React"
    ],
    "pattern": "(?:cheat\\s*sheet|quick\\s+reference|reference\\s+card)\\s+(?:for)?\\s*(.+)",
    "template": {
      "like": "${1} cheatsheet",
      "boost": "educational"
    },
    "confidence": 0.91
  },
  {
    "id": "info_what",
    "category": "informational",
    "examples": [
      "what is machine learning",
      "what are neural networks",
      "what does AI mean"
    ],
    "pattern": "what (is|are|does) (.+)",
    "template": {
      "like": "${2}"
    },
    "confidence": 0.9
  },
  {
    "id": "info_definition",
    "category": "informational",
    "examples": [
      "machine learning definition",
      "AI meaning",
      "what neural network means"
    ],
    "pattern": "(.+) (definition|meaning|means)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "definition"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "info_explain",
    "category": "informational",
    "examples": [
      "explain backpropagation",
      "explain how transformers work"
    ],
    "pattern": "explain (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "explanation"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "info_tutorial",
    "category": "informational",
    "examples": [
      "tutorial on deep learning",
      "pytorch tutorial",
      "guide to NLP"
    ],
    "pattern": "(tutorial|guide|course) (on|to|for)? (.+)",
    "template": {
      "like": "${3}",
      "where": {
        "type": "tutorial"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "step_by_step",
    "category": "informational",
    "examples": [
      "step by step guide",
      "walkthrough",
      "detailed instructions"
    ],
    "pattern": "(?:step\\s+by\\s+step|walkthrough|detailed\\s+instructions)\\s+(?:for|on)?\\s*(.+)",
    "template": {
      "like": "${1} tutorial detailed",
      "boost": "educational"
    },
    "confidence": 0.9
  },
  {
    "id": "tell_me_about",
    "category": "informational",
    "examples": [
      "tell me about machine learning",
      "explain neural networks"
    ],
    "pattern": "(?:tell\\s+me\\s+about|explain|describe)\\s+(.+)",
    "template": {
      "like": "${1}",
      "boost": "educational"
    },
    "confidence": 0.88
  },
  {
    "id": "use_cases",
    "category": "informational",
    "examples": [
      "use cases for blockchain",
      "applications of AI",
      "when to use React"
    ],
    "pattern": "(?:use\\s+cases?|applications?|when\\s+to\\s+use)\\s+(?:for|of)?\\s*(.+)",
    "template": {
      "like": "${1} applications",
      "boost": "practical"
    },
    "confidence": 0.88
  },
  {
    "id": "advanced_expert",
    "category": "informational",
    "examples": [
      "advanced Python techniques",
      "expert guide",
      "pro tips for"
    ],
    "pattern": "(?:advanced|expert|pro\\s+tips?)\\s+(?:techniques?|guide)?\\s*(?:for|on)?\\s*(.+)",
    "template": {
      "like": "${1} advanced",
      "boost": "expert"
    },
    "confidence": 0.87
  },
  {
    "id": "example_of",
    "category": "informational",
    "examples": [
      "example of machine learning",
      "sample code",
      "demo application"
    ],
    "pattern": "(?:example|sample|demo)\\s+(?:of|for)?\\s*(.+)",
    "template": {
      "like": "${1} example",
      "boost": "educational"
    },
    "confidence": 0.86
  },
  {
    "id": "info_how",
    "category": "informational",
    "examples": [
      "how to train a model",
      "how does clustering work",
      "how to implement search"
    ],
    "pattern": "how (to|does|do|can) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "tutorial"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "info_why",
    "category": "informational",
    "examples": [
      "why use vector databases",
      "why does overfitting occur"
    ],
    "pattern": "why (does|do|is|are|use) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "explanation"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "info_when",
    "category": "informational",
    "examples": [
      "when did deep learning start",
      "when was transformer invented"
    ],
    "pattern": "when (did|was|were|is|are) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "event"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "info_where",
    "category": "informational",
    "examples": [
      "where is Stanford located",
      "where can I find datasets"
    ],
    "pattern": "where (is|are|can|do) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "location"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "info_who",
    "category": "informational",
    "examples": [
      "who invented transformers",
      "who is Geoffrey Hinton"
    ],
    "pattern": "who (is|are|invented|created|made) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "person"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "question_can",
    "category": "informational",
    "examples": [
      "can transformers handle images",
      "can I use this for NLP"
    ],
    "pattern": "can (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "type": "capability"
      }
    },
    "confidence": 0.8
  },
  {
    "id": "question_should",
    "category": "informational",
    "examples": [
      "should I use tensorflow",
      "should we implement caching"
    ],
    "pattern": "should (I|we|you) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "recommendation"
      }
    },
    "confidence": 0.8
  },
  {
    "id": "nav_entity",
    "category": "navigational",
    "examples": [
      "OpenAI website",
      "Google homepage",
      "GitHub tensorflow"
    ],
    "pattern": "([A-Z][\\w]+) (website|homepage|page|site)",
    "template": {
      "where": {
        "name": "${1}",
        "type": "website"
      }
    },
    "confidence": 0.95
  },
  {
    "id": "official_docs",
    "category": "navigational",
    "examples": [
      "official React documentation",
      "official Python site"
    ],
    "pattern": "official\\s+(.+?)\\s*(?:documentation|docs|site|website)?",
    "template": {
      "like": "${1} official",
      "where": {
        "official": true
      }
    },
    "confidence": 0.93
  },
  {
    "id": "action_find",
    "category": "navigational",
    "examples": [
      "find papers about AI",
      "search for models",
      "look for datasets"
    ],
    "pattern": "(find|search for|look for) (.+)",
    "template": {
      "like": "${2}"
    },
    "confidence": 0.9
  },
  {
    "id": "synonym_find",
    "category": "navigational",
    "examples": [
      "find machine learning papers",
      "locate AI research",
      "get neural network docs"
    ],
    "pattern": "(?:find|locate|get|fetch|retrieve)\\s+(.+)",
    "template": {
      "like": "${1}"
    },
    "confidence": 0.9
  },
  {
    "id": "synonym_show",
    "category": "navigational",
    "examples": [
      "show me recent papers",
      "display all results",
      "list available options"
    ],
    "pattern": "(?:show\\s+me|display|list|view)\\s+(.+)",
    "template": {
      "like": "${1}"
    },
    "confidence": 0.88
  },
  {
    "id": "nav_goto",
    "category": "navigational",
    "examples": [
      "go to documentation",
      "navigate to settings"
    ],
    "pattern": "(go to|navigate to|open|show) (.+)",
    "template": {
      "where": {
        "name": "${2}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "nav_profile",
    "category": "navigational",
    "examples": [
      "John Smith profile",
      "user profile",
      "my account"
    ],
    "pattern": "(.+) (profile|account|page)",
    "template": {
      "where": {
        "name": "${1}",
        "type": "profile"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "action_show",
    "category": "navigational",
    "examples": [
      "show me papers",
      "display results",
      "list models"
    ],
    "pattern": "(show|display|list) (me )? (.+)",
    "template": {
      "like": "${3}"
    },
    "confidence": 0.85
  },
  {
    "id": "community_forum",
    "category": "navigational",
    "examples": [
      "React community",
      "Python forum",
      "Discord server for"
    ],
    "pattern": "(?:community|forum|discord|slack|discussion)\\s+(?:for)?\\s*(.+)",
    "template": {
      "like": "${1} community",
      "where": {
        "type": "community"
      }
    },
    "confidence": 0.84
  },
  {
    "id": "relational_by_author",
    "category": "relational",
    "examples": [
      "papers by Hinton",
      "research by OpenAI",
      "models by Google"
    ],
    "pattern": "(.+) by ([A-Z][\\w\\s]+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${2}"
      }
    },
    "confidence": 0.95
  },
  {
    "id": "relational_authored",
    "category": "relational",
    "examples": [
      "papers authored by Bengio",
      "articles written by researchers"
    ],
    "pattern": "(.+) (authored|written) by (.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${3}",
        "type": "author"
      }
    },
    "confidence": 0.95
  },
  {
    "id": "who_created",
    "category": "relational",
    "examples": [
      "who created React",
      "who wrote this paper",
      "who invented the internet"
    ],
    "pattern": "who\\s+(?:created|wrote|invented|developed|made)\\s+(.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "relationship": "creator"
      }
    },
    "confidence": 0.92
  },
  {
    "id": "relational_from_source",
    "category": "relational",
    "examples": [
      "papers from Stanford",
      "datasets from Google",
      "models from OpenAI"
    ],
    "pattern": "(.+) from ([A-Z][\\w\\s]+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${2}"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "relational_created_by",
    "category": "relational",
    "examples": [
      "models created by OpenAI",
      "datasets created by Google"
    ],
    "pattern": "(.+) (created|made|developed|built) by (.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${3}",
        "type": "created"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "relational_published",
    "category": "relational",
    "examples": [
      "papers published by Nature",
      "articles published in Science"
    ],
    "pattern": "(.+) published (by|in) (.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "from": "${3}",
        "type": "publisher"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "similar_to",
    "category": "relational",
    "examples": [
      "similar to Python",
      "papers like this one",
      "alternatives to React"
    ],
    "pattern": "(?:similar\\s+to|like|alternatives?\\s+to)\\s+(.+)",
    "template": {
      "like": "${1}",
      "boost": "similarity"
    },
    "confidence": 0.87
  },
  {
    "id": "relational_related",
    "category": "relational",
    "examples": [
      "papers related to transformers",
      "research connected to NLP"
    ],
    "pattern": "(.+) (related to|connected to|associated with) (.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "to": "${3}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "based_on",
    "category": "relational",
    "examples": [
      "based on React",
      "built with Python",
      "powered by"
    ],
    "pattern": "(?:based\\s+on|built\\s+with|powered\\s+by|using)\\s+(.+)",
    "template": {
      "like": "${1}",
      "connected": {
        "technology": "${1}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "spatial_in",
    "category": "spatial",
    "examples": [
      "companies in Silicon Valley",
      "universities in Boston",
      "labs in California"
    ],
    "pattern": "(.+) in ([A-Z][\\w\\s]+)",
    "template": {
      "like": "${1}",
      "where": {
        "location": "${2}"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "spatial_near",
    "category": "spatial",
    "examples": [
      "conferences near Boston",
      "labs near Stanford",
      "companies near me"
    ],
    "pattern": "(.+) near (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "location": {
          "near": "${2}"
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "spatial_at",
    "category": "spatial",
    "examples": [
      "researchers at MIT",
      "papers at conference",
      "work at Google"
    ],
    "pattern": "(.+) at ([A-Z][\\w]+)",
    "template": {
      "like": "${1}",
      "where": {
        "organization": "${2}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "where_location",
    "category": "spatial",
    "examples": [
      "where is Stanford University",
      "where can I find documentation"
    ],
    "pattern": "where\\s+(?:is|are|can\\s+I\\s+find)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "location": {
          "exists": true
        }
      }
    },
    "confidence": 0.83
  },
  {
    "id": "version_specific",
    "category": "technical",
    "examples": [
      "React version 18",
      "Python 3.11",
      "Node.js v20"
    ],
    "pattern": "(.+?)\\s+version\\s+(\\d+(?:\\.\\d+)*)",
    "template": {
      "like": "${1}",
      "where": {
        "version": "${2}"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "api_endpoint",
    "category": "technical",
    "examples": [
      "API endpoint for users",
      "REST API documentation",
      "GraphQL schema"
    ],
    "pattern": "(?:API|REST|GraphQL)\\s+(?:endpoint|documentation|schema)\\s+(?:for)?\\s*(.+)",
    "template": {
      "like": "${1} API",
      "where": {
        "type": "api"
      }
    },
    "confidence": 0.89
  },
  {
    "id": "security_vulnerability",
    "category": "technical",
    "examples": [
      "security issues",
      "vulnerability in",
      "CVE for"
    ],
    "pattern": "(?:security|vulnerability|CVE)\\s+(?:issues?|in|for)?\\s*(.+)",
    "template": {
      "like": "${1} security",
      "where": {
        "type": "security"
      }
    },
    "confidence": 0.89
  },
  {
    "id": "source_code",
    "category": "technical",
    "examples": [
      "source code for React",
      "GitHub repository",
      "code examples"
    ],
    "pattern": "(?:source\\s+code|github|repository|code\\s+examples?)\\s+(?:for|of)?\\s*(.+)",
    "template": {
      "like": "${1} code",
      "where": {
        "type": "code"
      }
    },
    "confidence": 0.87
  },
  {
    "id": "troubleshoot_fix",
    "category": "technical",
    "examples": [
      "troubleshoot Python error",
      "fix React issue",
      "solve problem with"
    ],
    "pattern": "(?:troubleshoot|fix|solve|debug|resolve)\\s+(.+?)\\s*(?:error|issue|problem|bug)?",
    "template": {
      "like": "${1} solution",
      "where": {
        "type": "troubleshooting"
      }
    },
    "confidence": 0.87
  },
  {
    "id": "performance_optimization",
    "category": "technical",
    "examples": [
      "optimize React performance",
      "speed up Python",
      "improve efficiency"
    ],
    "pattern": "(?:optimize|speed\\s+up|improve\\s+efficiency)\\s+(?:of)?\\s*(.+?)\\s*(?:performance)?",
    "template": {
      "like": "${1} optimization",
      "boost": "performance"
    },
    "confidence": 0.87
  },
  {
    "id": "migration_upgrade",
    "category": "technical",
    "examples": [
      "migrate from React 17 to 18",
      "upgrade guide",
      "migration path"
    ],
    "pattern": "(?:migrate|upgrade|migration\\s+path)\\s+(?:from\\s+)?(.+?)\\s+(?:to\\s+(.+))?",
    "template": {
      "like": "${1} ${2} migration",
      "where": {
        "type": "migration"
      }
    },
    "confidence": 0.86
  },
  {
    "id": "integration_with",
    "category": "technical",
    "examples": [
      "integrate React with Redux",
      "connect Python to database"
    ],
    "pattern": "(?:integrate|connect|interface)\\s+(.+?)\\s+(?:with|to)\\s+(.+)",
    "template": {
      "like": "${1} ${2} integration",
      "where": {
        "type": "integration"
      }
    },
    "confidence": 0.86
  },
  {
    "id": "requires_needs",
    "category": "technical",
    "examples": [
      "requires Python 3",
      "needs Node.js",
      "dependencies for"
    ],
    "pattern": "(?:requires?|needs?|dependencies\\s+for)\\s+(.+)",
    "template": {
      "like": "${1} requirements",
      "where": {
        "requirements": "${1}"
      }
    },
    "confidence": 0.86
  },
  {
    "id": "compatible_with",
    "category": "technical",
    "examples": [
      "compatible with Python 3",
      "works with React",
      "supports Windows"
    ],
    "pattern": "(?:compatible\\s+with|works\\s+with|supports)\\s+(.+)",
    "template": {
      "like": "${1} compatibility",
      "where": {
        "compatibility": "${1}"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "temporal_from_year",
    "category": "temporal",
    "examples": [
      "papers from 2023",
      "research from 2022",
      "models from last year"
    ],
    "pattern": "(.+) from (\\d{4})",
    "template": {
      "like": "${1}",
      "where": {
        "year": "${2}"
      }
    },
    "confidence": 0.95
  },
  {
    "id": "temporal_after",
    "category": "temporal",
    "examples": [
      "papers after 2020",
      "research after January",
      "models after GPT-3"
    ],
    "pattern": "(.+) after (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "greaterThan": "${2}"
        }
      }
    },
    "confidence": 0.9
  },
  {
    "id": "temporal_before",
    "category": "temporal",
    "examples": [
      "papers before 2020",
      "research before transformer",
      "models before BERT"
    ],
    "pattern": "(.+) before (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "lessThan": "${2}"
        }
      }
    },
    "confidence": 0.9
  },
  {
    "id": "temporal_recent",
    "category": "temporal",
    "examples": [
      "recent papers",
      "latest research",
      "new models"
    ],
    "pattern": "(recent|latest|new|newest) (.+)",
    "template": {
      "like": "${2}",
      "boost": "recent"
    },
    "confidence": 0.9
  },
  {
    "id": "temporal_this_period",
    "category": "temporal",
    "examples": [
      "papers this year",
      "research this month",
      "models this week"
    ],
    "pattern": "(.+) this (week|month|year|quarter)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "greaterThan": "start of ${2}"
        }
      }
    },
    "confidence": 0.9
  },
  {
    "id": "latest_newest",
    "category": "temporal",
    "examples": [
      "latest research",
      "newest papers",
      "most recent updates"
    ],
    "pattern": "(?:latest|newest|most\\s+recent|current)\\s+(.+)",
    "template": {
      "like": "${1}",
      "boost": "recent"
    },
    "confidence": 0.89
  },
  {
    "id": "last_period",
    "category": "temporal",
    "examples": [
      "last week",
      "past month",
      "previous year"
    ],
    "pattern": "(?:last|past|previous)\\s+(week|month|year|day)",
    "template": {
      "where": {
        "date": {
          "after": "${1}_ago"
        }
      }
    },
    "confidence": 0.87
  },
  {
    "id": "between_dates",
    "category": "temporal",
    "examples": [
      "between 2020 and 2023",
      "from January to March"
    ],
    "pattern": "between\\s+(\\d{4}|\\w+)\\s+(?:and|to)\\s+(\\d{4}|\\w+)",
    "template": {
      "where": {
        "date": {
          "between": [
            "${1}",
            "${2}"
          ]
        }
      }
    },
    "confidence": 0.86
  },
  {
    "id": "trending_popular",
    "category": "temporal",
    "examples": [
      "trending topics",
      "popular papers",
      "hot discussions"
    ],
    "pattern": "(?:trending|popular|hot|viral)\\s+(.+)",
    "template": {
      "like": "${1}",
      "boost": "popular"
    },
    "confidence": 0.86
  },
  {
    "id": "temporal_between",
    "category": "temporal",
    "examples": [
      "papers between 2020 and 2023",
      "research from 2021 to 2022"
    ],
    "pattern": "(.+) (between|from) (.+) (and|to) (.+)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "between": [
            "${3}",
            "${5}"
          ]
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "temporal_last_n_days",
    "category": "temporal",
    "examples": [
      "papers last 30 days",
      "research last week",
      "models last month"
    ],
    "pattern": "(.+) last (\\d+) (days|weeks|months|years)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "greaterThan": "${2} ${3} ago"
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "when_temporal",
    "category": "temporal",
    "examples": [
      "when was Python created",
      "when did AI start"
    ],
    "pattern": "when\\s+(?:was|did|were)\\s+(.+?)\\s+(?:created|started|invented|published)",
    "template": {
      "like": "${1}",
      "where": {
        "date": {
          "exists": true
        }
      }
    },
    "confidence": 0.85
  },
  {
    "id": "deprecated_obsolete",
    "category": "temporal",
    "examples": [
      "deprecated features",
      "obsolete methods",
      "legacy code"
    ],
    "pattern": "(?:deprecated|obsolete|legacy|outdated)\\s+(.+)",
    "template": {
      "like": "${1}",
      "where": {
        "status": "deprecated"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "roadmap_timeline",
    "category": "temporal",
    "examples": [
      "roadmap for React",
      "timeline of AI development",
      "history of Python"
    ],
    "pattern": "(?:roadmap|timeline|history)\\s+(?:for|of)\\s+(.+)",
    "template": {
      "like": "${1} roadmap",
      "boost": "timeline"
    },
    "confidence": 0.85
  },
  {
    "id": "under_development",
    "category": "temporal",
    "examples": [
      "under development",
      "coming soon",
      "in progress"
    ],
    "pattern": "(?:under\\s+development|coming\\s+soon|in\\s+progress|upcoming)\\s*(.+)?",
    "template": {
      "like": "${1}",
      "where": {
        "status": "development"
      }
    },
    "confidence": 0.84
  },
  {
    "id": "trans_buy",
    "category": "transactional",
    "examples": [
      "buy GPU",
      "purchase subscription",
      "order dataset"
    ],
    "pattern": "(buy|purchase|order|get) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "product",
        "available": true
      }
    },
    "confidence": 0.9
  },
  {
    "id": "trans_download",
    "category": "transactional",
    "examples": [
      "download model",
      "download dataset",
      "get paper PDF"
    ],
    "pattern": "(download|get|fetch) (.+)",
    "template": {
      "like": "${2}",
      "where": {
        "type": "downloadable"
      }
    },
    "confidence": 0.9
  },
  {
    "id": "trans_subscribe",
    "category": "transactional",
    "examples": [
      "subscribe to newsletter",
      "follow updates"
    ],
    "pattern": "(subscribe|follow|watch) (to )? (.+)",
    "template": {
      "like": "${3}",
      "where": {
        "type": "subscription"
      }
    },
    "confidence": 0.85
  },
  {
    "id": "action_get",
    "category": "transactional",
    "examples": [
      "get all papers",
      "fetch datasets",
      "retrieve models"
    ],
    "pattern": "(get|fetch|retrieve) (all )? (.+)",
    "template": {
      "like": "${3}"
    },
    "confidence": 0.85
  },
  {
    "id": "action_download",
    "category": "transactional",
    "examples": [
      "download Python",
      "download the dataset",
      "get the PDF"
    ],
    "pattern": "(?:download|get|fetch)\\s+(?:the\\s+)?(.+?)\\s*(?:pdf|file|document|dataset)?",
    "template": {
      "like": "${1}",
      "where": {
        "downloadable": true
      }
    },
    "confidence": 0.85
  },
  {
    "id": "action_create",
    "category": "transactional",
    "examples": [
      "create new project",
      "make a new document",
      "generate report"
    ],
    "pattern": "(?:create|make|generate|build)\\s+(?:new\\s+)?(.+)",
    "template": {
      "like": "${1} template",
      "boost": "tutorial"
    },
    "confidence": 0.82
  }
]

// Pre-computed embeddings (440.0KB base64)
const EMBEDDINGS_BASE64 = "[encoded data, 450560 characters]"

// Decode embeddings at startup (happens once, <10ms)
function decodeEmbeddings(): Uint8Array {
  if (typeof Buffer !== 'undefined') {
    // Node.js environment
    return Buffer.from(EMBEDDINGS_BASE64, 'base64')
  } else if (typeof atob !== 'undefined') {
    // Browser environment
    const binaryString = atob(EMBEDDINGS_BASE64)
    const bytes = new Uint8Array(binaryString.length)
    for (let i = 0; i < binaryString.length; i++) {
      bytes[i] = binaryString.charCodeAt(i)
    }
    return bytes
  }
  return new Uint8Array(0)
}

// Cached decoded embeddings
let decodedEmbeddings: Uint8Array | null = null

/**
 * Get pattern embeddings as a Map for fast lookup
 * This is called once at startup and cached
 */
export function getPatternEmbeddings(): Map<string, Float32Array> {
  if (!decodedEmbeddings) {
    decodedEmbeddings = decodeEmbeddings()
  }
  
  const embeddings = new Map<string, Float32Array>()
  const view = new DataView(decodedEmbeddings.buffer)
  const embeddingSize = 384
  
  EMBEDDED_PATTERNS.forEach((pattern, index) => {
    const offset = index * embeddingSize * 4
    const embedding = new Float32Array(embeddingSize)
    
    for (let i = 0; i < embeddingSize; i++) {
      embedding[i] = view.getFloat32(offset + i * 4, true)
    }
    
    embeddings.set(pattern.id, embedding)
  })
  
  return embeddings
}

// Export metadata for monitoring
export const PATTERNS_METADATA = {
  version: "2.0.0",
  totalPatterns: 220,
  categories: ["academic","aggregation","combined","commercial","comparative","contextual","conversational","domain","domain_specific","existence","filtering","informational","navigational","relational","spatial","technical","temporal","transactional"],
  domains: ["academic","ai","ecommerce","financial","legal","medical","programming","social","tech","technical"],
  embeddingDimensions: 384,
  averageConfidence: 0.891,
  coverage: {
    general: "95%+",
    programming: "95%+",
    ai_ml: "95%+",
    social: "90%+",
    medical_legal: "85-90%",
    financial_academic: "85-90%",
    ecommerce: "90%+",
    overall: "94-98%"
  },
  sizeBytes: {
    patterns: 65573,
    embeddings: 337920,
    total: 403493
  }
}

// Only log if not suppressed - controlled by logging configuration
import { prodLog } from '../utils/logger.js'
prodLog.info(`🧠 Brainy Pattern Library loaded: ${EMBEDDED_PATTERNS.length} patterns, ${(PATTERNS_METADATA.sizeBytes.total / 1024).toFixed(1)}KB total`)
