openprompt-lang 0.3.0 → 0.4.0

package/src/utils/config.js

@@ -1,22 +1,60 @@
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
+// @use(kind, contract, limit)
+// @kind(util)
+// @contract(in: projectDir -> out: normalizedConfig)
+// @limit(lines: 90)
+// @teachMe
+// ## ¿Qué hace config.js?
+// Carga prompt-lang.json desde el directorio del proyecto y mergea
+// recursivamente con defaults. Es el punto de entrada para toda
+// la configuración del framework.
+// ## ¿Por qué deep merge?
+// Shallow merge ({...defaults, ...user}) pierde campos anidados.
+// Si el usuario define {annotations: {enabled: false}}, el shallow
+// overwrite elimina annotations.strict. mergeDefaults() preserva
+// los defaults para sub-objetos no especificados.
+// ## ¿Cómo extender?
+// 1. Agrega nuevos defaults en getDefaultConfig()
+// 2. mergeDefaults mergea recursivamente objetos planos (no arrays)
+// 3. detectStack() se auto-corrige según archivos presentes
 
-const CONFIG_FILE = "prompt-lang.json";
+import { readFileSync, existsSync } from "fs"
+import { join } from "path"
+
+const CONFIG_FILE = "prompt-lang.json"
 
 export function loadConfig(dir = process.cwd()) {
-  const configPath = join(dir, CONFIG_FILE);
+  const configPath = join(dir, CONFIG_FILE)
   if (!existsSync(configPath)) {
-    return getDefaultConfig();
+    return getDefaultConfig()
   }
   try {
-    const raw = readFileSync(configPath, "utf-8");
-    return { ...getDefaultConfig(), ...JSON.parse(raw) };
+    const raw = readFileSync(configPath, "utf-8")
+    return mergeDefaults(getDefaultConfig(), JSON.parse(raw))
   } catch {
-    console.warn("⚠️  Error leyendo prompt-lang.json. Usando defaults.");
-    return getDefaultConfig();
+    console.warn("⚠️  Error leyendo prompt-lang.json. Usando defaults.")
+    return getDefaultConfig()
   }
 }
 
+function mergeDefaults(defaults, user) {
+  const result = { ...defaults }
+  for (const key of Object.keys(user)) {
+    if (
+      user[key] &&
+      typeof user[key] === "object" &&
+      !Array.isArray(user[key]) &&
+      defaults[key] &&
+      typeof defaults[key] === "object" &&
+      !Array.isArray(defaults[key])
+    ) {
+      result[key] = mergeDefaults(defaults[key], user[key])
+    } else {
+      result[key] = user[key]
+    }
+  }
+  return result
+}
+
 export function getDefaultConfig() {
   return {
     name: "mi-proyecto",
@@ -43,18 +81,28 @@ export function getDefaultConfig() {
       ignore: [".env", "*.local", "dist"],
       output: "contexto.md",
     },
-  };
+  }
 }
 
 export function detectStack(dir = process.cwd()) {
-  const has = (file) => existsSync(join(dir, file));
+  const has = (file) => existsSync(join(dir, file))
+
+  let hasReactInDeps = false
+  try {
+    const pkgPath = join(dir, "package.json")
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+      hasReactInDeps = !!(pkg.dependencies?.react || pkg.devDependencies?.react)
+    }
+  } catch {}
+
   return {
-    react: has("package.json") && existsSync(join(dir, "src", "App.tsx")),
+    react: has("package.json") && (existsSync(join(dir, "src", "App.tsx")) || hasReactInDeps),
     vite: has("vite.config.ts"),
     tailwind: has("tailwind.config.ts") || has("tailwind.config.js"),
     ionic: has("ionic.config.json"),
     tauri: has("src-tauri"),
     supabase: has("supabase") || has("supabase-config.ts"),
     typescript: has("tsconfig.json"),
-  };
+  }
 }

package/src/utils/error-learner.js

@@ -0,0 +1,203 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { join, relative, dirname } from "path"
+import { getLanguagePath, getLanguage, getLanguageIndex } from "./language-loader.js"
+import { findAllFiles } from "./file-utils.js"
+
+const LEARN_ERROR_REGEX =
+  /\/\/\s*@learn-error\s+id=([\w-]+)(?:\s+template=([\w-]+))?\s+input='([^']*)'\s+expected=([\w-]+)\s+actual=([\w-]+)\s+fix='([^']*)'(?:\s+category=([\w-]+))?/g
+
+export function parseLearnErrors(content, sourceFile = "unknown", langId = "react") {
+  const errors = []
+  let match
+
+  while ((match = LEARN_ERROR_REGEX.exec(content)) !== null) {
+    const errorId = match[1]
+    const explicitTemplate = match[2]
+    const input = match[3]
+    const expected = match[4]
+    const actual = match[5]
+    const fix = match[6]
+    const category = match[7] || "unclassified"
+
+    const template = explicitTemplate || resolveTemplateId(errorId, langId)
+
+    errors.push({
+      id: errorId,
+      template,
+      problem: buildProblemDescription(input, expected, actual),
+      solution: fix,
+      input,
+      expected,
+      actual,
+      category,
+      date: new Date().toISOString().split("T")[0],
+      sourceFile,
+    })
+  }
+
+  return errors
+}
+
+function resolveTemplateId(errorId, langId) {
+  const index = getLanguageIndex(langId)
+  if (!index?.templates) return errorId.split("-")[0]?.toLowerCase() || "unknown"
+
+  const prefix = errorId.split("-")[0]?.toLowerCase()
+  if (!prefix) return "unknown"
+
+  // Direct match: template id starts with prefix
+  const direct = index.templates.find((t) => t.id.toLowerCase().startsWith(prefix))
+  if (direct) return direct.id
+
+  // Fuzzy match: template id contains prefix
+  const fuzzy = index.templates.find((t) => t.id.toLowerCase().includes(prefix))
+  if (fuzzy) return fuzzy.id
+
+  // Match by fixHistory: any error in fixHistory has matching prefix
+  const byHistory = index.templates.find((t) =>
+    (t.fixHistory || []).some((fid) => fid.toLowerCase().startsWith(prefix))
+  )
+  if (byHistory) return byHistory.id
+
+  return prefix
+}
+
+export function scanForLearnErrors(sourceDir, langId = "react") {
+  const results = []
+  const allFiles = findAllFiles(sourceDir)
+
+  for (const file of allFiles) {
+    try {
+      const content = readFileSync(file, "utf-8")
+      const errors = parseLearnErrors(content, file, langId)
+      results.push(...errors)
+    } catch {}
+  }
+
+  return results
+}
+
+export function persistErrors(errors, langId = "react") {
+  const langPath = getLanguagePath(langId)
+  if (!langPath) {
+    throw new Error(`Language module "${langId}" not found`)
+  }
+
+  const indexPath = join(langPath, "INDEX.json")
+  let index = {
+    language: langId,
+    version: "1.0.0",
+    updated: new Date().toISOString().split("T")[0],
+    categories: {},
+    templates: [],
+    errorsLearned: [],
+  }
+
+  if (existsSync(indexPath)) {
+    try {
+      index = JSON.parse(readFileSync(indexPath, "utf-8"))
+    } catch {}
+  }
+
+  if (!index.errorsLearned) index.errorsLearned = []
+
+  let added = 0
+  for (const err of errors) {
+    const exists = index.errorsLearned.some((e) => e.id === err.id)
+    if (!exists) {
+      index.errorsLearned.push(err)
+      added++
+    }
+  }
+
+  index.updated = new Date().toISOString().split("T")[0]
+  writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8")
+  return added
+}
+
+export function generateTestFromError(error, langId = "react") {
+  const template = getTestTemplate(langId)
+
+  const testName = `${error.id}: ${error.problem}`
+  const testBody = template
+    .replace(/{{TEST_NAME}}/g, testName)
+    .replace(/{{INPUT}}/g, error.input)
+    .replace(/{{EXPECTED}}/g, error.expected)
+    .replace(/{{ACTUAL}}/g, error.actual)
+    .replace(/{{FIX}}/g, error.solution)
+    .replace(/{{ERROR_ID}}/g, error.id)
+    .replace(/{{CATEGORY}}/g, error.category)
+
+  return testBody
+}
+
+export function generateTests(errors, langId = "react") {
+  return errors.map((err) => generateTestFromError(err, langId))
+}
+
+export function writeTestFile(errors, outputPath, langId = "react") {
+  const tests = generateTests(errors, langId)
+  const content = [
+    "// @generated by openPrompt-Lang qa-gen",
+    "// @description: Auto-generated tests from learned errors",
+    "// @date: " + new Date().toISOString().split("T")[0],
+    `// @errors: ${errors.map((e) => e.id).join(", ")}`,
+    "",
+    'import { describe, it, expect } from "vitest"',
+    "",
+    ...tests,
+    "",
+  ].join("\n")
+
+  mkdirSync(dirname(outputPath), { recursive: true })
+  writeFileSync(outputPath, content, "utf-8")
+}
+
+export function buildProblemDescription(input, expected, actual) {
+  return `${input} → expected ${expected}, got ${actual}`
+}
+
+// ─── Test templates ──────────────────────────────────────────────────────────
+
+function getTestTemplate(langId) {
+  const templates = {
+    react: `
+describe("{{TEST_NAME}}", () => {
+  it("should handle {{INPUT}} correctly", async () => {
+    // Learned from error {{ERROR_ID}} ({{CATEGORY}})
+    // Problem: {{INPUT}} → expected {{EXPECTED}}, got {{ACTUAL}}
+    // Fix applied: {{FIX}}
+    
+    const input = "{{INPUT}}"
+    const expected = "{{EXPECTED}}"
+    
+    // TODO: Implement actual test based on your service/hook
+    // const result = await yourFunction(input)
+    // expect(result.status).toBe(expected)
+    
+    expect(true).toBe(true)
+  })
+})
+`,
+    vue: `
+describe("{{TEST_NAME}}", () => {
+  it("should handle {{INPUT}} correctly", async () => {
+    // Learned from error {{ERROR_ID}} ({{CATEGORY}})
+    // Problem: {{INPUT}} → expected {{EXPECTED}}, got {{ACTUAL}}
+    // Fix applied: {{FIX}}
+    
+    const input = "{{INPUT}}"
+    const expected = "{{EXPECTED}}"
+    
+    // TODO: Implement actual test based on your composable
+    // const result = await yourFunction(input)
+    // expect(result).toBe(expected)
+    
+    expect(true).toBe(true)
+  })
+})
+`,
+  }
+
+  return templates[langId] || templates.react
+}

package/src/utils/file-utils.js

@@ -0,0 +1,119 @@
+// @use(kind, contract, limit)
+// @kind(util)
+// @contract(in: dir, options -> out: string[])
+// @limit(lines: 50)
+// @teachMe
+// ## ¿Qué hace file-utils.js?
+// Unifica los dos findAllFiles duplicados (extract.js y error-learner.js)
+// en una sola función configurable. También provee findComponentFiles
+// que antes estaba en extract.js.
+// ## ¿Por qué unificarlo?
+// Dos implementaciones con diferente lógica de exclusión (una omitía dist,
+// la otra no) causaban bugs inconsistentes entre commands.
+
+import { readFileSync, readdirSync, statSync, existsSync } from "fs"
+import { join, extname, basename, dirname } from "path"
+
+const DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"]
+const DEFAULT_EXCLUDE = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  ".cache",
+])
+
+export function findAllFiles(dir, options = {}) {
+  const {
+    extensions = DEFAULT_EXTENSIONS,
+    excludeDirs = DEFAULT_EXCLUDE,
+    skipDotDirs = true,
+  } = options
+
+  const results = []
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (skipDotDirs && entry.name.startsWith(".")) continue
+        if (excludeDirs.has(entry.name)) continue
+        results.push(...findAllFiles(fullPath, options))
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase()
+        // null = accept all files, array = filter
+        if (!extensions || extensions.includes(ext)) {
+          results.push(fullPath)
+        }
+      }
+    }
+  } catch {}
+  return results
+}
+
+export function findComponentFiles(dir) {
+  const candidates = findAllFiles(dir, { extensions: [".tsx", ".jsx", ".ts", ".js"] })
+  return candidates.filter((f) => {
+    try {
+      const content = readFileSync(f, "utf-8")
+      const isReact =
+        content.includes("import React") ||
+        content.includes('from "react"') ||
+        content.includes("from 'react'")
+      const isComponent =
+        content.includes("export ") && (content.includes("function ") || content.includes("const "))
+      return isReact && isComponent && (f.endsWith(".tsx") || f.endsWith(".jsx"))
+    } catch {
+      return false
+    }
+  })
+}
+
+export function analyzeImports(dir, files) {
+  const importMap = new Map()
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file, "utf-8")
+      const imports = []
+
+      const importRegex = /import\s+(?:\{\s*([^}]+)\}|(\w+))\s+from\s+['"]\.\/([^'"]+)['"]/g
+      let match
+      while ((match = importRegex.exec(content)) !== null) {
+        if (match[1]) {
+          const names = match[1]
+            .split(",")
+            .map((n) => n.trim().replace(/\s+as\s+\w+$/, ""))
+            .filter(Boolean)
+          imports.push(...names)
+        } else if (match[2]) {
+          imports.push(match[2])
+        }
+      }
+
+      importMap.set(file, imports)
+    } catch {
+      importMap.set(file, [])
+    }
+  }
+
+  return importMap
+}
+
+export function countFiles(dir) {
+  const counts = { total: 0, ts: 0, tsx: 0, js: 0, jsx: 0, css: 0, other: 0 }
+  const allFiles = findAllFiles(dir, { extensions: null }) // null = all files
+
+  for (const f of allFiles) {
+    counts.total++
+    const ext = extname(f).slice(1)
+    if (counts[ext] !== undefined) counts[ext]++
+    else counts.other++
+  }
+  return counts
+}

package/src/utils/language-loader.js

@@ -0,0 +1,167 @@
+import { readFileSync, existsSync, readdirSync } from "fs"
+import { join, dirname } from "path"
+import { fileURLToPath } from "url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const LANGS_DIR = join(__dirname, "..", "templates", "langs")
+
+let cachedLanguages = null
+
+function discoverLanguages() {
+  if (!existsSync(LANGS_DIR)) return []
+
+  const entries = readdirSync(LANGS_DIR, { withFileTypes: true })
+  const languages = []
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const modulePath = join(LANGS_DIR, entry.name, "MODULE.json")
+    if (!existsSync(modulePath)) continue
+
+    try {
+      const module = JSON.parse(readFileSync(modulePath, "utf-8"))
+      if (module.id && module.name) {
+        languages.push({
+          ...module,
+          _path: join(LANGS_DIR, entry.name),
+        })
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return languages
+}
+
+export function getLanguages(forceRefresh = false) {
+  if (!cachedLanguages || forceRefresh) {
+    cachedLanguages = discoverLanguages()
+  }
+  return cachedLanguages
+}
+
+export function getLanguage(id) {
+  const langs = getLanguages()
+  return langs.find((l) => l.id === id) || null
+}
+
+export function getLanguagePath(id) {
+  const lang = getLanguage(id)
+  return lang ? lang._path : null
+}
+
+export function getLanguageIndex(id) {
+  const langPath = getLanguagePath(id)
+  if (!langPath) return null
+
+  const indexPath = join(langPath, "INDEX.json")
+  if (!existsSync(indexPath)) return null
+
+  try {
+    return JSON.parse(readFileSync(indexPath, "utf-8"))
+  } catch {
+    return null
+  }
+}
+
+export function getTemplate(id, langId) {
+  const index = getLanguageIndex(langId)
+  if (!index) return null
+
+  const entry = index.templates?.find((t) => t.id === id)
+  if (!entry) return null
+
+  const langPath = getLanguagePath(langId)
+  const templatePath = join(langPath, entry.file)
+
+  if (!existsSync(templatePath)) return null
+
+  return {
+    metadata: entry,
+    content: readFileSync(templatePath, "utf-8"),
+    path: templatePath,
+  }
+}
+
+export function searchTemplates(query, filters = {}) {
+  const langs = filters.language ? [getLanguage(filters.language)].filter(Boolean) : getLanguages()
+  const results = []
+
+  const terms = query.toLowerCase().split(/\s+/)
+
+  for (const lang of langs) {
+    const index = getLanguageIndex(lang.id)
+    if (!index?.templates) continue
+
+    for (const tmpl of index.templates) {
+      const searchable = [
+        tmpl.name,
+        tmpl.description,
+        ...(tmpl.tags || []),
+        ...(tmpl.purposes || []),
+        tmpl.category,
+        tmpl.id,
+      ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase()
+
+      const match = terms.every((t) => searchable.includes(t))
+      if (!match) continue
+
+      if (filters.category && tmpl.category !== filters.category) continue
+      if (filters.darkMode !== undefined && tmpl.darkMode !== filters.darkMode) continue
+
+      results.push({
+        ...tmpl,
+        language: lang.id,
+        languageName: lang.name,
+      })
+    }
+  }
+
+  return results
+}
+
+export function getTemplateErrors(langId) {
+  const index = getLanguageIndex(langId)
+  if (!index?.errorsLearned) return []
+  return index.errorsLearned
+}
+
+export function getErrorsByTemplate(langId, templateId) {
+  const index = getLanguageIndex(langId)
+  if (!index?.errorsLearned) return []
+  return index.errorsLearned.filter((e) => e.template === templateId)
+}
+
+export function getStructure(id) {
+  const lang = getLanguage(id)
+  if (!lang?.structure) return null
+  return lang.structure
+}
+
+export function getProjectTypes(id) {
+  const lang = getLanguage(id)
+  if (!lang?.projectTypes) return null
+  return lang.projectTypes
+}
+
+export function getExtensions(id) {
+  const lang = getLanguage(id)
+  if (!lang?.extensions) return []
+  return lang.extensions
+}
+
+export function getUiStyles(id) {
+  const lang = getLanguage(id)
+  if (!lang?.uiStyles) return ["none"]
+  return lang.uiStyles
+}
+
+export function getTags(id) {
+  const lang = getLanguage(id)
+  if (!lang?.tags) return null
+  return lang.tags
+}

package/src/utils/template-utils.js

@@ -0,0 +1,45 @@
+/**
+ * Shared utilities for extracting lesson content and tags from templates.
+ */
+
+export function extractLesson(content) {
+  const lines = content.split("\n")
+  const lessonLines = []
+  let inLesson = false
+
+  for (const line of lines) {
+    if (line.includes("@teachMe")) {
+      inLesson = true
+      continue
+    }
+    if (inLesson) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      if (!trimmed.startsWith("//")) break
+      if (
+        /^\/\/\s+@(kind|contract|props|limit|use|deps|compose|platform|state|test|pattern|meta|scope|forbidden|goodPractice|badPractice|template|source|reuse|extracted|learn-error)\b/.test(
+          trimmed
+        )
+      )
+        break
+      if (trimmed.startsWith("// ##")) {
+        lessonLines.push(line.replace(/^\/\/\s*##\s*/, "## ").trim())
+        continue
+      }
+      const cleaned = line.replace(/^\/\/\s*/, "").trim()
+      if (cleaned) lessonLines.push(cleaned)
+    }
+  }
+
+  return lessonLines.join("\n").trim() || null
+}
+
+export function extractTags(content, tagName) {
+  const results = []
+  const regex = new RegExp(`// @${tagName}:\\s*(.+)`, "g")
+  let match
+  while ((match = regex.exec(content)) !== null) {
+    results.push(match[1].trim())
+  }
+  return results
+}

package/src/vite-plugin/index.js

@@ -0,0 +1,54 @@
+import { readFileSync, existsSync } from "fs"
+
+const builtinTags = JSON.parse(
+  readFileSync(new URL("../annotations/tags.json", import.meta.url), "utf-8")
+)
+
+function countNesting(line, openChars = "({[", closeChars = ")}]") {
+  let depth = 0
+  for (const ch of line) {
+    if (openChars.includes(ch)) depth++
+    if (closeChars.includes(ch)) depth--
+  }
+  return depth
+}
+
+export function openPromptAnnotations(options = {}) {
+  const customTags = options.tags || []
+  const tags = [...builtinTags, ...customTags]
+  const tagPattern = new RegExp(
+    `^\\s*@(${tags.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\(`
+  )
+
+  return {
+    name: "openprompt-lang",
+    enforce: "pre",
+
+    transform(code, id) {
+      if (!/\.([cm]?[jt]sx?|vue)$/.test(id)) return null
+
+      const lines = code.split("\n")
+      const result = []
+      let i = 0
+
+      while (i < lines.length) {
+        const trimmed = lines[i].trim()
+
+        if (tagPattern.test(trimmed)) {
+          let depth = countNesting(lines[i])
+          while (depth > 0 && i + 1 < lines.length) {
+            i++
+            depth += countNesting(lines[i])
+          }
+          i++
+          continue
+        }
+
+        result.push(lines[i])
+        i++
+      }
+
+      return result.join("\n")
+    },
+  }
+}