openprompt-lang 0.3.0 → 0.4.0

package/src/utils/annotations.js

@@ -1,339 +1,370 @@
-import chalk from "chalk";
+import chalk from "chalk"
+import { getBuiltinTags, getAnnotationTags } from "../annotations/registry.js"
 
 // ─── Parser ────────────────────────────────────────────────────────────────
 
-export function parseAnnotations(code) {
-  const annotations = [];
-  const lines = code.split("\n");
-  const errors = [];
+export function parseAnnotations(code, options = {}) {
+  const annotations = []
+  const lines = code.split("\n")
+  const errors = []
+  const { langId, projectConfig } = options
+  const knownTags = projectConfig ? getAnnotationTags(langId, projectConfig) : getBuiltinTags()
 
-  let currentBlock = null;
-  let inBlock = false;
+  let currentBlock = null
+  let inBlock = false
 
   for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
+    const line = lines[i]
+    const trimmed = line.trim()
 
     // Detecta bloque de anotaciones /* ... */
     if (trimmed.startsWith("/*")) {
-      inBlock = true;
-      currentBlock = "";
-      const cleaned = trimmed.replace(/^\/\*+\s*/, "").replace(/\s*\*+\/$/, "").trim();
-      // Solo procesamos si hay contenido (si la línea era solo /*, esperamos a la siguiente)
+      inBlock = true
+      currentBlock = ""
+      const cleaned = trimmed
+        .replace(/^\/\*+\s*/, "")
+        .replace(/\s*\*+\/$/, "")
+        .trim()
       if (cleaned) {
-        currentBlock += cleaned + " ";
+        currentBlock += cleaned + " "
       }
       if (trimmed.includes("*/")) {
-        inBlock = false;
+        inBlock = false
         if (currentBlock.trim()) {
-          annotations.push(...parseTags(currentBlock));
+          annotations.push(...parseTags(currentBlock))
         }
-        currentBlock = null;
+        currentBlock = null
       }
-      continue;
+      continue
     }
 
     if (inBlock) {
       if (trimmed.includes("*/")) {
-        const content = trimmed.replace(/\s*\*+\/$/, "").trim();
-        currentBlock += content + " ";
-        inBlock = false;
-        annotations.push(...parseTags(currentBlock));
-        currentBlock = null;
+        const content = trimmed.replace(/\s*\*+\/$/, "").trim()
+        currentBlock += content + " "
+        inBlock = false
+        annotations.push(...parseTags(currentBlock))
+        currentBlock = null
       } else {
-        const content = trimmed.replace(/^\s*\*\s*/, "").trim();
-        currentBlock += content + " ";
+        const content = trimmed.replace(/^\s*\*\s*/, "").trim()
+        currentBlock += content + " "
       }
-      continue;
+      continue
     }
 
-    // Detecta línea de comentario con @
-    if (trimmed.startsWith("//") && trimmed.includes("@")) {
-      const tagLine = trimmed.replace(/^\/\/\s*/, "");
-      annotations.push(...parseTags(tagLine));
+    // Detecta // comment inline (incluso después de código)
+    const commentIdx = trimmed.lastIndexOf("//")
+    const hasInlineComment = commentIdx !== -1 && trimmed.includes("@", commentIdx)
+    if (hasInlineComment) {
+      const afterComment = trimmed.slice(commentIdx + 2).trim()
+      if (afterComment.startsWith("@") || afterComment.includes("@")) {
+        annotations.push(...parseTags(afterComment))
+        continue
+      }
+    }
+
+    // Detecta anotación como código (sin //)
+    const codeMatch = trimmed.match(/^@(\w[\w-]*)\(/)
+    if (codeMatch && knownTags.includes(codeMatch[1])) {
+      annotations.push(...parseTags(trimmed))
     }
   }
 
   // Si quedó un bloque abierto sin cerrar, lo forzamos
   if (inBlock && currentBlock) {
-    annotations.push(...parseTags(currentBlock));
-    errors.push("Comentario multinea sin cerrar. Las anotaciones se procesaron igual.");
+    annotations.push(...parseTags(currentBlock))
+    errors.push("Comentario multinea sin cerrar. Las anotaciones se procesaron igual.")
   }
 
   // Extraer @use primero (determina qué tags son válidos)
-  const useTag = annotations.find((a) => a.name === "use");
+  const useTag = annotations.find((a) => a.name === "use")
 
   // Edge case: @use(*) → todos los tags son válidos
-  let validTags = [];
+  let validTags = []
   if (useTag) {
-    const starArg = useTag.args.find((a) => a.value === "*");
+    const starArg = useTag.args.find((a) => a.value === "*")
     if (starArg) {
-      validTags = []; // empty = todos permitidos
+      validTags = [] // empty = todos permitidos
     } else {
-      validTags = useTag.args.map((a) => a.value);
+      validTags = useTag.args.map((a) => a.value)
     }
   }
 
   // Edge case: @use presente pero sin tags reales
   if (useTag && useTag.args.length === 0) {
-    errors.push("@use() está vacío — no se importaron tags");
+    errors.push("@use() está vacío — no se importaron tags")
   }
 
   // Edge case: @use sin anotaciones de tags abajo
   if (useTag && annotations.filter((a) => a.name !== "use").length === 0) {
-    errors.push("@use presente pero no hay anotaciones de tags en el archivo");
+    errors.push("@use presente pero no hay anotaciones de tags en el archivo")
   }
 
-  return { annotations, validTags, parseErrors: errors };
+  return { annotations, validTags, parseErrors: errors }
 }
 
 function parseTags(text) {
-  const tags = [];
+  const tags = []
 
-  if (!text || text.trim().length === 0) return tags;
+  if (!text || text.trim().length === 0) return tags
 
   // Parseador manual con conteo de profundidad de paréntesis
-  let i = 0;
+  let i = 0
   while (i < text.length) {
     // Buscar @ seguido de nombre de tag
-    const atIndex = text.indexOf("@", i);
-    if (atIndex === -1) break;
+    const atIndex = text.indexOf("@", i)
+    if (atIndex === -1) break
 
     // Extraer nombre del tag (letras, números, guiones)
-    const nameMatch = text.slice(atIndex + 1).match(/^\w+/);
-    if (!nameMatch) { i = atIndex + 1; continue; }
+    const nameMatch = text.slice(atIndex + 1).match(/^[\w-]+/)
+    if (!nameMatch) {
+      i = atIndex + 1
+      continue
+    }
 
-    const name = nameMatch[0];
-    let argsRaw = "";
-    let parenDepth = 0;
-    let pos = atIndex + 1 + name.length;
+    const name = nameMatch[0]
+    let argsRaw = ""
+    let parenDepth = 0
+    let pos = atIndex + 1 + name.length
 
     // Si hay paréntesis, extraemos con depth tracking
     if (pos < text.length && text[pos] === "(") {
-      parenDepth = 1;
-      pos++;
-      const start = pos;
+      parenDepth = 1
+      pos++
+      const start = pos
       while (pos < text.length && parenDepth > 0) {
-        if (text[pos] === "(") parenDepth++;
-        else if (text[pos] === ")") parenDepth--;
-        pos++;
+        if (text[pos] === "(") parenDepth++
+        else if (text[pos] === ")") parenDepth--
+        pos++
       }
-      argsRaw = text.slice(start, pos - 1).trim();
+      argsRaw = text.slice(start, pos - 1).trim()
     }
 
-    tags.push({ name, args: parseArgs(argsRaw), raw: `@${name}(${argsRaw})` });
-    i = pos;
+    tags.push({ name, args: parseArgs(argsRaw), raw: `@${name}(${argsRaw})` })
+    i = pos
   }
 
-  return tags;
+  return tags
 }
 
 function parseArgs(raw) {
-  const args = [];
+  const args = []
 
-  if (!raw || raw.trim().length === 0) return args;
+  if (!raw || raw.trim().length === 0) return args
 
-  const trimmed = raw.trim();
-  const lenient = trimmed.replace(/\)$/, "");
+  const trimmed = raw.trim()
 
   // Intenta parsear como JSON object primero: { key: value, ... }
   if (trimmed.startsWith("{")) {
     try {
-      const obj = JSON.parse(trimmed);
+      const obj = JSON.parse(trimmed)
       for (const [key, value] of Object.entries(obj)) {
-        args.push({ key, value: String(value), type: "kv" });
+        args.push({ key, value: String(value), type: "kv" })
       }
-      return args;
+      return args
     } catch {
       // Fallback: parsear como TypeScript object { key: type, key?: type }
-      const tsProps = parseTsObject(trimmed);
+      const tsProps = parseTsObject(trimmed)
       if (tsProps.length > 0) {
-        args.push(...tsProps);
-        return args;
+        args.push(...tsProps)
+        return args
       }
       // Edge case: JSON inválido → error reportado en validación
-      args.push({ key: null, value: trimmed, type: "invalid-json" });
-      return args;
+      args.push({ key: null, value: trimmed, type: "invalid-json" })
+      return args
     }
   }
 
   // Detectar mezcla de subtags, flags y key:values
   // Dividir por coma respetando corchetes
-  const parts = splitRespectingBrackets(lenient);
+  const parts = splitRespectingBrackets(trimmed)
 
   for (const part of parts) {
-    const p = part.trim();
-    if (!p) continue;
+    const p = part.trim()
+    if (!p) continue
 
     // Subtag: @algo: [lista]
-    const subMatch = p.match(/^@(\w+)\s*:\s*\[([^\]]*)\]/);
+    const subMatch = p.match(/^@(\w+)\s*:\s*\[([^\]]*)\]/)
     if (subMatch) {
       args.push({
         key: subMatch[1],
         value: subMatch[2].split(",").map((s) => s.trim().replace(/["']/g, "")),
         type: "subtag",
-      });
-      continue;
+      })
+      continue
     }
 
     // Flag: @algo
-    const flagMatch = p.match(/^@(\w+)/);
+    const flagMatch = p.match(/^@(\w+)/)
     if (flagMatch) {
-      args.push({ key: flagMatch[1], value: true, type: "flag" });
-      continue;
+      args.push({ key: flagMatch[1], value: true, type: "flag" })
+      continue
     }
 
     // Key: value
-    const kvMatch = p.match(/^(\w+)\s*:\s*(.+)/);
+    const kvMatch = p.match(/^(\w+)\s*:\s*(.+)/)
     if (kvMatch) {
-      args.push({ key: kvMatch[1].trim(), value: kvMatch[2].trim().replace(/["']/g, ""), type: "kv" });
-      continue;
+      args.push({
+        key: kvMatch[1].trim(),
+        value: kvMatch[2].trim().replace(/["']/g, ""),
+        type: "kv",
+      })
+      continue
     }
 
     // Valor plano
-    args.push({ key: null, value: p.replace(/["']/g, ""), type: "plain" });
+    args.push({ key: null, value: p.replace(/["']/g, ""), type: "plain" })
   }
 
-  return args;
+  return args
 }
 
 function parseTsObject(raw) {
   // Parsear { key: type, key?: type, "key": "type" }
-  const inner = raw.trim().replace(/^{/, "").replace(/}$/, "").trim();
-  if (!inner) return [];
-  const parts = splitRespectingBrackets(inner);
-  const result = [];
+  const inner = raw.trim().replace(/^{/, "").replace(/}$/, "").trim()
+  if (!inner) return []
+  const parts = splitRespectingBrackets(inner)
+  const result = []
   for (const part of parts) {
-    const p = part.trim();
-    if (!p) continue;
+    const p = part.trim()
+    if (!p) continue
     // key: type  o  key?: type  o  "key": "type"
-    const m = p.match(/^"([^"]+)"\s*:\s*(.+)/) || p.match(/^(\w+\??)\s*:\s*(.+)/);
+    const m = p.match(/^"([^"]+)"\s*:\s*(.+)/) || p.match(/^(\w+\??)\s*:\s*(.+)/)
     if (m) {
-      const key = m[1].replace(/\?$/, "?");
-      let value = m[2].trim().replace(/["']/g, "");
+      const key = m[1].replace(/\?$/, "?")
+      let value = m[2].trim().replace(/["']/g, "")
       // Quitar default values: = "Default" → ignorar
-      value = value.replace(/\s*=\s*.+$/, "").trim();
-      result.push({ key, value, type: "kv" });
+      value = value.replace(/\s*=\s*.+$/, "").trim()
+      result.push({ key, value, type: "kv" })
     }
   }
-  return result;
+  return result
 }
 
 function splitRespectingBrackets(str) {
-  const result = [];
-  let current = "";
-  let depth = 0;
+  const result = []
+  let current = ""
+  let depth = 0
 
   for (const ch of str) {
     if (ch === "[" || ch === "{" || ch === "(") {
-      depth++;
-      current += ch;
+      depth++
+      current += ch
     } else if (ch === "]" || ch === "}" || ch === ")") {
-      depth--;
-      current += ch;
+      depth--
+      current += ch
     } else if (ch === "," && depth === 0) {
-      result.push(current.trim());
-      current = "";
+      result.push(current.trim())
+      current = ""
     } else {
-      current += ch;
+      current += ch
     }
   }
-  if (current.trim()) result.push(current.trim());
-  return result;
+  if (current.trim()) result.push(current.trim())
+  return result
 }
 
 // ─── Validador ──────────────────────────────────────────────────────────────
 
 export function validateAnnotations(annotations, validTags, options = {}) {
-  const errors = [];
-  const warnings = [];
-  const tags = annotations.filter((a) => a.name !== "use");
+  const errors = []
+  const warnings = []
+  const tags = annotations.filter((a) => a.name !== "use")
 
   // Validar tags contra @use
-  const useAll = validTags.length === 0 && annotations.some(
-    (a) => a.name === "use" && a.args.some((x) => x.value === "*")
-  );
+  const useAll =
+    validTags.length === 0 &&
+    annotations.some((a) => a.name === "use" && a.args.some((x) => x.value === "*"))
 
   if (validTags.length > 0 && !useAll) {
     for (const tag of tags) {
       if (!validTags.includes(tag.name)) {
-        errors.push(`Tag @${tag.name} no está importado. Agrega @use(${tag.name})`);
+        errors.push(`Tag @${tag.name} no está importado. Agrega @use(${tag.name})`)
       }
     }
   }
 
   // Validar @kind
-  const kindTag = tags.find((t) => t.name === "kind");
+  const kindTag = tags.find((t) => t.name === "kind")
   const validKinds = [
-    "hook", "component", "page", "service", "store",
-    "util", "type", "layout", "feature",
-  ];
+    "hook",
+    "component",
+    "page",
+    "service",
+    "store",
+    "util",
+    "type",
+    "layout",
+    "feature",
+  ]
 
   if (kindTag) {
-    const kindValue = kindTag.args[0]?.value;
+    const kindValue = kindTag.args[0]?.value
 
     // Edge case: @kind sin valor
     if (!kindValue || kindValue.trim() === "") {
-      errors.push("@kind() necesita un valor. Válidos: " + validKinds.join(", "));
+      errors.push("@kind() necesita un valor. Válidos: " + validKinds.join(", "))
     } else if (!validKinds.includes(kindValue)) {
-      errors.push(
-        `@kind("${kindValue}") inválido. Valores válidos: ${validKinds.join(", ")}`
-      );
+      errors.push(`@kind("${kindValue}") inválido. Valores válidos: ${validKinds.join(", ")}`)
     }
 
     if (kindValue && validKinds.includes(kindValue)) {
-      const hasContract = tags.some((t) => t.name === "contract");
-      const hasProps = tags.some((t) => t.name === "props");
-      const hasLimit = tags.some((t) => t.name === "limit");
-      const hasCompose = tags.some((t) => t.name === "compose");
+      const hasContract = tags.some((t) => t.name === "contract")
+      const hasProps = tags.some((t) => t.name === "props")
+      const hasLimit = tags.some((t) => t.name === "limit")
+      const hasCompose = tags.some((t) => t.name === "compose")
 
       if (kindValue === "hook" && !hasContract) {
-        warnings.push("@kind(hook) debería tener @contract");
+        warnings.push("@kind(hook) debería tener @contract")
       }
       if (kindValue === "component" && hasContract) {
-        errors.push("@kind(component) no puede tener @contract. Usa @props en su lugar.");
+        errors.push("@kind(component) no puede tener @contract. Usa @props en su lugar.")
       }
       if (kindValue === "component" && !hasProps) {
-        warnings.push("@kind(component) debería tener @props");
+        warnings.push("@kind(component) debería tener @props")
       }
       if (kindValue === "page" && !hasCompose) {
-        warnings.push("@kind(page) debería tener @compose (debe componer subcomponentes)");
+        warnings.push("@kind(page) debería tener @compose (debe componer subcomponentes)")
       }
       if (kindValue === "service" && !hasContract) {
-        errors.push("@kind(service) requiere @contract");
+        errors.push("@kind(service) requiere @contract")
       }
       if (kindValue === "hook" && hasProps) {
-        errors.push("@kind(hook) no puede tener @props");
+        errors.push("@kind(hook) no puede tener @props")
       }
       if (kindValue === "type" && hasLimit) {
-        warnings.push("@kind(type) no necesita @limit");
+        warnings.push("@kind(type) no necesita @limit")
       }
       if (kindValue === "store") {
-        const hasDeps = tags.some((t) => t.name === "deps");
+        const hasDeps = tags.some((t) => t.name === "deps")
         if (!hasDeps) {
-          warnings.push("@kind(store) debería tener @deps (zustand, context, etc.)");
+          warnings.push("@kind(store) debería tener @deps (zustand, context, etc.)")
         }
       }
 
       // Límites por defecto según kind
-      const limitTag = tags.find((t) => t.name === "limit");
+      const limitTag = tags.find((t) => t.name === "limit")
       if (limitTag) {
-        const linesArg = limitTag.args.find((a) => a.key === "lines");
+        const linesArg = limitTag.args.find((a) => a.key === "lines")
         if (linesArg) {
           const maxLines = {
-            hook: 80, component: 120, page: 200,
-            service: 150, store: 100, layout: 150,
-          };
-          const expected = maxLines[kindValue];
-          const numVal = parseInt(linesArg.value);
+            hook: 80,
+            component: 120,
+            page: 200,
+            service: 150,
+            store: 100,
+            layout: 150,
+          }
+          const expected = maxLines[kindValue]
+          const numVal = parseInt(linesArg.value)
           if (expected && !isNaN(numVal) && numVal > expected) {
             warnings.push(
               `@kind(${kindValue}) @limit(lines) debería ser ≤ ${expected} (actual: ${linesArg.value})`
-            );
+            )
           }
           // Edge case: límite 0 o negativo
           if (!isNaN(numVal) && numVal <= 0) {
-            errors.push(`@limit(lines: ${numVal}) debe ser mayor a 0`);
+            errors.push(`@limit(lines: ${numVal}) debe ser mayor a 0`)
           }
         }
       }
@@ -341,16 +372,14 @@ export function validateAnnotations(annotations, validTags, options = {}) {
   }
 
   // Validar @contract — edge cases
-  const contractTag = tags.find((t) => t.name === "contract");
+  const contractTag = tags.find((t) => t.name === "contract")
   if (contractTag) {
-    const args = contractTag.args;
-    const hasInput = args.some((a) => a.key === "in" || a.type === "plain");
-    const hasOutput = args.find((a) => a.key === "out" || a.value === "->");
-    const contractText = contractTag.raw;
+    const args = contractTag.args
+    const hasInput = args.some((a) => a.key === "in" || a.type === "plain")
+    const contractText = contractTag.raw
 
-    // Edge case: contrato vacío
     if (args.length === 0 && contractTag.raw === "@contract()") {
-      errors.push("@contract() está vacío. Formato: @contract(in: tipo -> out: tipo @error: tipo)");
+      errors.push("@contract() está vacío. Formato: @contract(in: tipo -> out: tipo @error: tipo)")
     }
 
     // Edge case: sin input claro
@@ -358,153 +387,170 @@ export function validateAnnotations(annotations, validTags, options = {}) {
       // Puede ser formato @contract(in: -> out:) sin inputs
       if (contractText.includes("->")) {
         // tiene flecha pero sin "in:" → intentamos extraer
-        const parts = contractText.split("->");
-        const inputPart = parts[0].replace("@contract(", "").replace("@contract", "").trim();
+        const parts = contractText.split("->")
+        const inputPart = parts[0].replace("@contract(", "").replace("@contract", "").trim()
         if (!inputPart || inputPart === "in: " || inputPart === "in:") {
-          errors.push("@contract: falta definir tipos de entrada (in:)");
+          errors.push("@contract: falta definir tipos de entrada (in:)")
         }
       }
     }
 
     // Edge case: @contract(in: any -> out: any)
     if (contractTag.raw.includes("any")) {
-      warnings.push("@contract usa 'any' — especifica tipos concretos");
+      warnings.push("@contract usa 'any' — especifica tipos concretos")
     }
   }
 
   // Validar @props — edge case JSON inválido
-  const propsTag = tags.find((t) => t.name === "props");
+  const propsTag = tags.find((t) => t.name === "props")
   if (propsTag) {
-    const hasInvalidJson = propsTag.args.some((a) => a.type === "invalid-json");
+    const hasInvalidJson = propsTag.args.some((a) => a.type === "invalid-json")
     if (hasInvalidJson) {
-      errors.push(`@props(${propsTag.args[0]?.value}) no es un JSON válido. Formato: @props({ key: type })`);
+      errors.push(
+        `@props(${propsTag.args[0]?.value}) no es un JSON válido. Formato: @props({ key: type })`
+      )
     }
   }
 
   // Validar @platform — edge case web + capacitor
-  const platformTag = tags.find((t) => t.name === "platform");
-  const depsTag = tags.find((t) => t.name === "deps");
+  const platformTag = tags.find((t) => t.name === "platform")
+  const depsTag = tags.find((t) => t.name === "deps")
   if (platformTag && depsTag) {
-    const platforms = platformTag.args.map((a) => a.value);
-    const deps = depsTag.args;
+    const platforms = platformTag.args.map((a) => a.value)
+    const deps = depsTag.args
 
     if (platforms.includes("web")) {
-      const hasCapacitor = deps.some(
-        (d) => d.value && (String(d.value).includes("@capacitor"))
-      );
+      const hasCapacitor = deps.some((d) => d.value && String(d.value).includes("@capacitor"))
       if (hasCapacitor) {
-        errors.push("@platform(web) no es compatible con @capacitor/*");
+        errors.push("@platform(web) no es compatible con @capacitor/*")
       }
-      const hasTauri = deps.some(
-        (d) => d.value && String(d.value).includes("@tauri-apps")
-      );
+      const hasTauri = deps.some((d) => d.value && String(d.value).includes("@tauri-apps"))
       if (hasTauri) {
-        errors.push("@platform(web) no es compatible con @tauri-apps/*");
+        errors.push("@platform(web) no es compatible con @tauri-apps/*")
       }
     }
 
     if (platforms.includes("mobile")) {
-      const hasTauri = deps.some(
-        (d) => d.value && String(d.value).includes("@tauri-apps")
-      );
+      const hasTauri = deps.some((d) => d.value && String(d.value).includes("@tauri-apps"))
       if (hasTauri) {
-        errors.push("@platform(mobile) no es compatible con @tauri-apps/*");
+        errors.push("@platform(mobile) no es compatible con @tauri-apps/*")
       }
     }
     if (platforms.includes("desktop")) {
-      const hasCapacitor = deps.some(
-        (d) => d.value && String(d.value).includes("@capacitor")
-      );
+      const hasCapacitor = deps.some((d) => d.value && String(d.value).includes("@capacitor"))
       if (hasCapacitor) {
-        errors.push("@platform(desktop) no es compatible con @capacitor/*");
+        errors.push("@platform(desktop) no es compatible con @capacitor/*")
       }
     }
   }
 
   // Validar @limit — edge cases de valores
-  const limitTag = tags.find((t) => t.name === "limit");
+  const limitTag = tags.find((t) => t.name === "limit")
   if (limitTag) {
     for (const arg of limitTag.args) {
       if (arg.type === "kv" && arg.value !== undefined) {
-        const num = parseInt(arg.value);
-        if (isNaN(num) || (arg.value.includes(".") && isNaN(parseFloat(arg.value)))) {
-          errors.push(`@limit(${arg.key}: "${arg.value}") esperaba un número, recibió texto`);
+        if (!/^\d+(\.\d+)?$/.test(arg.value)) {
+          errors.push(`@limit(${arg.key}: "${arg.value}") esperaba un número, recibió texto`)
         }
       }
     }
     // Edge case: @limit() vacío
     if (limitTag.args.length === 0) {
-      errors.push("@limit() está vacío. Especifica al menos un límite: @limit(lines: 120)");
+      errors.push("@limit() está vacío. Especifica al menos un límite: @limit(lines: 120)")
     }
   }
 
   // Validar @forbidden
-  const forbiddenTag = tags.find((t) => t.name === "forbidden");
+  const forbiddenTag = tags.find((t) => t.name === "forbidden")
   if (forbiddenTag) {
     if (forbiddenTag.args.length === 0) {
-      warnings.push("@forbidden() está vacío — no prohíbe nada");
+      warnings.push("@forbidden() está vacío — no prohíbe nada")
     }
   }
 
   // Validar @scope breaking
-  const scopeTag = tags.find((t) => t.name === "scope");
+  const scopeTag = tags.find((t) => t.name === "scope")
   if (scopeTag) {
-    const breaking = scopeTag.args.find((a) => a.key === "breaking");
+    const breaking = scopeTag.args.find((a) => a.key === "breaking")
     if (breaking && breaking.value === "true") {
-      warnings.push("@scope(breaking: true) — el commit debe indicar breaking change (!)");
+      warnings.push("@scope(breaking: true) — el commit debe indicar breaking change (!)")
     }
   }
 
   // Validar @test
-  const testTag = tags.find((t) => t.name === "test");
+  const testTag = tags.find((t) => t.name === "test")
   if (testTag) {
-    const coverage = testTag.args.find((a) => a.key === "coverage");
+    const coverage = testTag.args.find((a) => a.key === "coverage")
     if (coverage) {
-      const val = parseInt(coverage.value);
+      const val = parseInt(coverage.value)
       if (!isNaN(val) && val > 100) {
-        errors.push(`@test(@coverage: ${val}) no puede exceder 100`);
+        errors.push(`@test(@coverage: ${val}) no puede exceder 100`)
       }
     }
   }
 
+  // Validar @pattern
+  const patternTag = tags.find((t) => t.name === "pattern")
+  if (patternTag) {
+    const validPatterns = [
+      "compound",
+      "composition",
+      "generic",
+      "render-prop",
+      "provider",
+      "singleton",
+    ]
+    const patternValue = patternTag.args[0]?.value
+
+    if (!patternValue || patternValue.trim() === "") {
+      errors.push("@pattern() necesita un valor. Válidos: " + validPatterns.join(", "))
+    } else if (patternValue === "inheritance") {
+      warnings.push("@pattern(inheritance) — usa @pattern(composition) en su lugar")
+    } else if (!validPatterns.includes(patternValue)) {
+      warnings.push(
+        `@pattern("${patternValue}") no es un valor estándar. Válidos: ${validPatterns.join(", ")}`
+      )
+    }
+  }
+
   // Validar @state error → debe tener @contract (solo en kinds que requieren contract)
-  const stateTag = tags.find((t) => t.name === "state");
+  const stateTag = tags.find((t) => t.name === "state")
   if (stateTag) {
-    const hasError = stateTag.args.some((a) => a.value === "error");
-    const hasContract = tags.some((t) => t.name === "contract");
-    const kindValue = kindTag?.args[0]?.value;
-    const contractKinds = ["hook", "service"];
+    const hasError = stateTag.args.some((a) => a.value === "error")
+    const hasContract = tags.some((t) => t.name === "contract")
+    const kindValue = kindTag?.args[0]?.value
+    const contractKinds = ["hook", "service"]
     if (hasError && !hasContract && contractKinds.includes(kindValue)) {
-      warnings.push("@state(error) presente pero no hay @contract — define el tipo de error");
+      warnings.push("@state(error) presente pero no hay @contract — define el tipo de error")
     }
   }
 
-  return { errors, warnings };
+  return { errors, warnings }
 }
 
 // ─── API pública ────────────────────────────────────────────────────────────
 
-export function lintFile(code, strict = false) {
-  const { annotations, validTags, parseErrors } = parseAnnotations(code);
+export function lintFile(code, strict = false, options = {}) {
+  const { annotations, validTags, parseErrors } = parseAnnotations(code, options)
 
   if (annotations.length === 0) {
-    return { annotations: [], errors: parseErrors, warnings: [] };
+    return { annotations: [], errors: parseErrors, warnings: [] }
   }
 
-  const { errors, warnings } = validateAnnotations(annotations, validTags);
-  const allErrors = [...parseErrors, ...errors];
-  const allWarnings = [...warnings];
+  const { errors, warnings } = validateAnnotations(annotations, validTags)
+  const allErrors = [...parseErrors, ...errors]
+  const allWarnings = [...warnings]
 
   if (strict && allWarnings.length > 0) {
-    allErrors.push(...allWarnings.map(w => `[strict] ${w}`));
-    return { annotations, errors: allErrors, warnings: [] };
+    allErrors.push(...allWarnings.map((w) => `[strict] ${w}`))
+    return { annotations, errors: allErrors, warnings: allWarnings }
   }
 
   return {
     annotations,
     errors: allErrors,
     warnings: allWarnings,
-  };
+  }
 }
 
-export { parseArgs };
+export { parseArgs }