openprompt-lang 0.3.0 → 0.4.0

package/src/commands/context.js

@@ -1,206 +1,281 @@
-import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from "fs";
-import { join, relative, extname, basename, dirname } from "path";
-import { loadConfig } from "../utils/config.js";
-import { lintFile } from "../utils/annotations.js";
-import chalk from "chalk";
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from "fs"
+import { join, relative, extname, basename, dirname } from "path"
+import { loadConfig } from "../utils/config.js"
+import { lintFile } from "../utils/annotations.js"
+import chalk from "chalk"
 
 const IGNORED_DIRS = new Set([
-  ".git", "node_modules", "dist", "build", ".next", ".gemini",
-  "coverage", ".nyc_output", "__pycache__", ".cache",
-]);
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".gemini",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  ".cache",
+])
 
 const IGNORED_FILES = new Set([
-  "package-lock.json", "yarn.lock", ".env.local", ".env",
-  "contexto.md", "proyecto_completo.md",
-]);
+  "package-lock.json",
+  "yarn.lock",
+  ".env.local",
+  ".env",
+  "contexto.md",
+  "proyecto_completo.md",
+])
 
 const IGNORED_EXTENSIONS = new Set([
-  ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".webp",
-  ".pdf", ".woff", ".woff2", ".ttf", ".eot", ".otf",
-  ".mp4", ".mp3", ".avi", ".mov",
-  ".zip", ".tar", ".gz", ".rar",
-  ".exe", ".dll", ".so", ".dylib",
-  ".db", ".sqlite", ".sqlite3",
-]);
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".svg",
+  ".webp",
+  ".pdf",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp4",
+  ".mp3",
+  ".avi",
+  ".mov",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+])
 
 const CODE_EXTENSIONS = new Set([
-  ".ts", ".tsx", ".js", ".jsx", ".json", ".css", ".html",
-  ".md", ".mdx", ".py", ".rs", ".toml", ".yaml", ".yml",
-  ".sh", ".bash", ".zsh", ".env.example",
-]);
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".css",
+  ".html",
+  ".md",
+  ".mdx",
+  ".py",
+  ".rs",
+  ".toml",
+  ".yaml",
+  ".yml",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".env.example",
+])
 
 function shouldIgnore(name, relPath, isDir) {
-  if (isDir) return IGNORED_DIRS.has(name);
-  if (IGNORED_FILES.has(name)) return true;
-  const ext = extname(name).toLowerCase();
-  if (IGNORED_EXTENSIONS.has(ext)) return true;
-  return false;
+  if (isDir) return IGNORED_DIRS.has(name)
+  if (IGNORED_FILES.has(name)) return true
+  const ext = extname(name).toLowerCase()
+  if (IGNORED_EXTENSIONS.has(ext)) return true
+  return false
+}
+
+function matchesGlob(name, pattern) {
+  // Convert simple glob (*.ext) to regex
+  if (pattern.includes("*")) {
+    const regex = new RegExp(
+      "^" +
+        pattern
+          .split("*")
+          .map((s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&"))
+          .join(".*") +
+        "$"
+    )
+    return regex.test(name)
+  }
+  return name.includes(pattern)
 }
 
 function generateTree(dirPath, prefix = "", configIgnore = []) {
-  let treeStr = "";
+  let treeStr = ""
   try {
-    const entries = readdirSync(dirPath).sort();
+    const entries = readdirSync(dirPath).sort()
     const filtered = entries.filter((e) => {
-      if (IGNORED_DIRS.has(e) || IGNORED_FILES.has(e)) return false;
-      if (configIgnore.some((ig) => e.includes(ig))) return false;
-      return true;
-    });
+      if (IGNORED_DIRS.has(e) || IGNORED_FILES.has(e)) return false
+      if (configIgnore.some((ig) => matchesGlob(e, ig))) return false
+      return true
+    })
 
     for (let i = 0; i < filtered.length; i++) {
-      const entry = filtered[i];
-      const fullPath = join(dirPath, entry);
-      const isLast = i === filtered.length - 1;
-      const connector = isLast ? "└── " : "├── ";
-      treeStr += `${prefix}${connector}${entry}\n`;
+      const entry = filtered[i]
+      const fullPath = join(dirPath, entry)
+      const isLast = i === filtered.length - 1
+      const connector = isLast ? "└── " : "├── "
+      treeStr += `${prefix}${connector}${entry}\n`
 
       if (statSync(fullPath).isDirectory()) {
-        const extension = isLast ? "    " : "│   ";
-        treeStr += generateTree(fullPath, prefix + extension, configIgnore);
+        const extension = isLast ? "    " : "│   "
+        treeStr += generateTree(fullPath, prefix + extension, configIgnore)
       }
     }
   } catch {
     // PermissionError o similar
   }
-  return treeStr;
+  return treeStr
 }
 
 export async function context(options) {
-  const baseDir = process.cwd();
-  const outputFile = options.output || "contexto.md";
-  const config = loadConfig(baseDir);
-  const configIgnores = config.extractor?.ignore || [];
+  const baseDir = process.cwd()
+  const outputFile = options.output || "contexto.md"
+  const config = loadConfig(baseDir)
+  const configIgnores = config.extractor?.ignore || []
 
-  console.log(chalk.cyan("🔍 Extrayendo contexto del proyecto..."));
+  console.log(chalk.cyan("🔍 Extrayendo contexto del proyecto..."))
 
-  let output = "# Contexto del Proyecto\n\n";
+  let output = "# Contexto del Proyecto\n\n"
 
   // Incluir AGENTS.md si existe
-  const agentsPath = join(baseDir, "AGENTS.md");
+  const agentsPath = join(baseDir, "AGENTS.md")
   if (existsSync(agentsPath)) {
-    output += "## AGENTS.md (Contexto para IA)\n\n";
-    output += readFileSync(agentsPath, "utf-8") + "\n\n";
+    output += "## AGENTS.md (Contexto para IA)\n\n"
+    output += readFileSync(agentsPath, "utf-8") + "\n\n"
   }
 
   // Incluir prompt-lang.json si existe
-  const configPath = join(baseDir, "prompt-lang.json");
+  const configPath = join(baseDir, "prompt-lang.json")
   if (existsSync(configPath)) {
-    output += "## prompt-lang.json (Configuración)\n\n";
-    output += "```json\n";
-    output += readFileSync(configPath, "utf-8") + "\n";
-    output += "```\n\n";
+    output += "## prompt-lang.json (Configuración)\n\n"
+    output += "```json\n"
+    output += readFileSync(configPath, "utf-8") + "\n"
+    output += "```\n\n"
   }
 
   // Recorrer archivos
-  let fileCount = 0;
+  let fileCount = 0
   const walkDir = (dirPath) => {
-    let entries;
+    let entries
     try {
-      entries = readdirSync(dirPath);
+      entries = readdirSync(dirPath)
     } catch {
-      return;
+      return
     }
 
     for (const entry of entries) {
-      const fullPath = join(dirPath, entry);
-      let stat;
+      const fullPath = join(dirPath, entry)
+      let stat
       try {
-        stat = statSync(fullPath);
+        stat = statSync(fullPath)
       } catch {
-        continue;
+        continue
       }
 
       if (stat.isDirectory()) {
         if (!shouldIgnore(entry, relative(baseDir, fullPath), true)) {
-          walkDir(fullPath);
+          walkDir(fullPath)
         }
-        continue;
+        continue
       }
 
       // Ignorar archivos
-      if (shouldIgnore(entry, relative(baseDir, fullPath), false)) continue;
+      if (shouldIgnore(entry, relative(baseDir, fullPath), false)) continue
 
-      const ext = extname(entry).toLowerCase();
-      if (!CODE_EXTENSIONS.has(ext)) continue;
+      const ext = extname(entry).toLowerCase()
+      if (!CODE_EXTENSIONS.has(ext)) continue
 
       // Ignorar el propio output
-      const relPath = relative(baseDir, fullPath);
-      if (relPath === outputFile) continue;
+      const relPath = relative(baseDir, fullPath)
+      if (relPath === outputFile) continue
 
       // Scope filtering
       if (options.scope) {
         try {
-          const content = readFileSync(fullPath, "utf-8");
-          if (!content.includes(`@scope`)) continue;
-          if (!content.includes(`module: ${options.scope}`)) continue;
+          const content = readFileSync(fullPath, "utf-8")
+          if (!content.includes(`@scope`)) continue
+          if (!content.includes(`module: ${options.scope}`)) continue
         } catch {
-          continue;
+          continue
         }
       }
 
-      fileCount++;
+      fileCount++
 
-      let content;
+      let content
       try {
-        content = readFileSync(fullPath, "utf-8");
+        content = readFileSync(fullPath, "utf-8")
       } catch {
-        continue;
+        continue
       }
 
       // Detectar lenguaje para el bloque de código
       const langMap = {
-        ".ts": "typescript", ".tsx": "tsx", ".js": "javascript",
-        ".jsx": "jsx", ".json": "json", ".css": "css",
-        ".html": "html", ".md": "markdown", ".mdx": "mdx",
-        ".py": "python", ".rs": "rust", ".toml": "toml",
-        ".yaml": "yaml", ".yml": "yaml", ".sh": "bash",
-      };
-      const lang = langMap[ext] || "";
-
-      output += `### Archivo: ${relPath}\n`;
-      output += `\`\`\`${lang}\n`;
-      output += content;
-      if (!content.endsWith("\n")) output += "\n";
-      output += "```\n\n";
+        ".ts": "typescript",
+        ".tsx": "tsx",
+        ".js": "javascript",
+        ".jsx": "jsx",
+        ".json": "json",
+        ".css": "css",
+        ".html": "html",
+        ".md": "markdown",
+        ".mdx": "mdx",
+        ".py": "python",
+        ".rs": "rust",
+        ".toml": "toml",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+        ".sh": "bash",
+      }
+      const lang = langMap[ext] || ""
+
+      output += `### Archivo: ${relPath}\n`
+      output += `\`\`\`${lang}\n`
+      output += content
+      if (!content.endsWith("\n")) output += "\n"
+      output += "```\n\n"
 
       // Si tiene anotaciones PromptLang, mostrarlas como metadata
       if (options.ai !== false) {
         try {
-          const { annotations, errors, warnings } = lintFile(content);
+          const { annotations, errors, warnings } = lintFile(content)
           if (annotations.length > 0) {
-            output += `*Anotaciones PromptLang:* `;
+            output += `*Anotaciones PromptLang:* `
             for (const ann of annotations) {
-              output += `\`@${ann.name}`;
+              output += `\`@${ann.name}`
               if (ann.args.length > 0) {
                 const argsStr = ann.args
                   .map((a) => (a.key ? `${a.key}: ${a.value}` : a.value))
-                  .join(", ");
-                output += `(${argsStr})`;
+                  .join(", ")
+                output += `(${argsStr})`
               }
-              output += "` ";
+              output += "` "
             }
-            output += "\n\n";
+            output += "\n\n"
           }
         } catch {
           // Ignorar errores de parseo en la extracción
         }
       }
     }
-  };
+  }
 
-  walkDir(baseDir);
+  walkDir(baseDir)
 
   // Agregar estructura de carpetas al final
-  output += "# Estructura de Carpetas\n\n";
-  output += "```text\n";
-  output += `${basename(baseDir)}/\n`;
-  output += generateTree(baseDir, "", configIgnores);
-  output += "```\n";
+  output += "# Estructura de Carpetas\n\n"
+  output += "```text\n"
+  output += `${basename(baseDir)}/\n`
+  output += generateTree(baseDir, "", configIgnores)
+  output += "```\n"
 
   // Escribir archivo
-  const outputPath = join(baseDir, outputFile);
-  writeFileSync(outputPath, output, "utf-8");
+  const outputPath = join(baseDir, outputFile)
+  writeFileSync(outputPath, output, "utf-8")
 
-  console.log(chalk.green(`✅ Contexto extraído: ${fileCount} archivos`));
-  console.log(chalk.green(`📄 Output: ${outputFile}`));
+  console.log(chalk.green(`✅ Contexto extraído: ${fileCount} archivos`))
+  console.log(chalk.green(`📄 Output: ${outputFile}`))
 }

package/src/commands/extract.js

@@ -0,0 +1,242 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { join, relative, extname, basename, dirname } from "path"
+import chalk from "chalk"
+import { getLanguageIndex, getLanguagePath, getLanguages } from "../utils/language-loader.js"
+import { findAllFiles, findComponentFiles, analyzeImports } from "../utils/file-utils.js"
+
+const REUSE_THRESHOLD = 2 // minimum times a component must be imported to qualify
+
+export async function extractTemplates(sourceDir, options) {
+  const cwd = process.cwd()
+  const srcPath = join(cwd, sourceDir || "src")
+  const langId = options.lang || "react"
+  const minReuse = parseInt(options.minReuse) || REUSE_THRESHOLD
+  const dryRun = options.dryRun || false
+
+  const langPath = getLanguagePath(langId)
+  if (!langPath) {
+    console.log(chalk.red(`\n❌ Language module "${langId}" not found\n`))
+    return
+  }
+
+  if (!existsSync(srcPath)) {
+    console.log(chalk.red(`\n❌ Source directory not found: ${srcPath}\n`))
+    return
+  }
+
+  console.log(chalk.cyan(`\n🔍 Scanning ${srcPath} for reusable components...\n`))
+
+  // 1. Find all component files
+  const componentFiles = findComponentFiles(srcPath)
+  if (componentFiles.length === 0) {
+    console.log(chalk.yellow("  No component files found.\n"))
+    return
+  }
+
+  console.log(chalk.gray(`  Found ${componentFiles.length} component files\n`))
+
+  // 2. Analyze imports to calculate reuse
+  const importMap = analyzeImports(srcPath, componentFiles)
+  const usageCount = new Map()
+
+  for (const [, imports] of importMap) {
+    for (const imp of imports) {
+      usageCount.set(imp, (usageCount.get(imp) || 0) + 1)
+    }
+  }
+
+  // 3. Rank by reuse percentage
+  const totalFiles = componentFiles.length
+  const ranked = componentFiles
+    .map((f) => {
+      const name = basename(f).replace(/\.(tsx|ts)$/, "")
+      const imports = usageCount.get(name) || 0
+      const reuse = totalFiles > 0 ? (imports / totalFiles) * 100 : 0
+      return { file: f, name, imports, reuse }
+    })
+    .sort((a, b) => b.reuse - a.reuse)
+
+  // 4. Filter by min reuse
+  const candidates = ranked.filter((c) => c.imports >= minReuse)
+
+  console.log(chalk.blue(`\n  Reuse analysis:\n`))
+  for (const c of ranked.slice(0, 10)) {
+    const bar =
+      "█".repeat(Math.round(c.reuse / 5)) + "░".repeat(Math.max(0, 20 - Math.round(c.reuse / 5)))
+    const marker = c.imports >= minReuse ? chalk.green("✅") : chalk.gray("⬜")
+    console.log(
+      `  ${marker} ${chalk.bold(c.name)} — ${c.imports}/${totalFiles} imports (${c.reuse.toFixed(0)}%)`
+    )
+    console.log(`     ${bar}`)
+  }
+
+  if (candidates.length === 0) {
+    console.log(
+      chalk.yellow(`\n  No components meet the minimum reuse threshold (${minReuse}+ imports).\n`)
+    )
+    return
+  }
+
+  console.log(
+    chalk.green(
+      `\n  ${candidates.length} components qualify for extraction (≥${minReuse} imports)\n`
+    )
+  )
+
+  // 5. Extract to language module lib/
+  const libDir = join(langPath, "lib")
+
+  if (!dryRun) {
+    mkdirSync(libDir, { recursive: true })
+
+    // Load existing index to update
+    const index = getLanguageIndex(langId) || {
+      language: langId,
+      version: "1.0.0",
+      updated: new Date().toISOString().split("T")[0],
+      categories: {},
+      templates: [],
+      errorsLearned: [],
+    }
+
+    // Ensure lib category exists
+    if (!index.categories) index.categories = {}
+    if (!index.categories["lib/extracted"]) {
+      index.categories["lib/extracted"] = {
+        name: "Extracted from Projects",
+        description: "Components automatically extracted from existing projects",
+      }
+    }
+
+    for (const c of candidates) {
+      const content = readFileSync(c.file, "utf-8")
+      const ext = extname(c.file) || ".tsx"
+      const destName = `${c.name}.template${ext}`
+      const destPath = join(libDir, destName)
+
+      // Add @extracted annotation if not present
+      const annotated = content.startsWith("// @extracted")
+        ? content
+        : `// @extracted\n// @source: ${relative(cwd, c.file)}\n// @reuse: ${c.reuse.toFixed(0)}% (${c.imports}/${totalFiles} files)\n${content}`
+
+      writeFileSync(destPath, annotated, "utf-8")
+      console.log(chalk.green(`  ✅ Extracted: ${c.name} → lib/${destName}`))
+
+      // Add to index
+      const existingIdx = index.templates.findIndex((t) => t.id === c.name)
+      const entry = {
+        id: c.name,
+        name: c.name,
+        description: `Auto-extracted from ${relative(cwd, c.file)}`,
+        category: "lib/extracted",
+        purposes: ["reusable"],
+        file: `lib/${destName}`,
+        testFile: null,
+        variants: [],
+        sizes: [],
+        darkMode: false,
+        responsive: false,
+        dependencies: [],
+        tags: ["extracted"],
+        hasTeachMe: false,
+        fixHistory: [],
+      }
+
+      if (existingIdx >= 0) {
+        index.templates[existingIdx] = entry
+      } else {
+        index.templates.push(entry)
+      }
+    }
+
+    // Update INDEX.json
+    index.updated = new Date().toISOString().split("T")[0]
+    writeFileSync(join(langPath, "INDEX.json"), JSON.stringify(index, null, 2), "utf-8")
+    console.log(chalk.green(`\n  ✅ INDEX.json updated with ${candidates.length} new templates`))
+  }
+
+  console.log(
+    chalk.cyan(`\n  Done. ${candidates.length} components extracted to ${relative(cwd, libDir)}/\n`)
+  )
+  console.log(chalk.gray(`  Run: npx openPrompt-Lang component list to see them`))
+  console.log(
+    chalk.gray(`  Run: npx openPrompt-Lang component add <name> --template to use them\n`)
+  )
+}
+
+export async function extractAnalyze(sourceDir, options) {
+  const cwd = process.cwd()
+  const srcPath = join(cwd, sourceDir || "src")
+
+  if (!existsSync(srcPath)) {
+    console.log(chalk.red(`\n❌ Source directory not found: ${srcPath}\n`))
+    return
+  }
+
+  console.log(chalk.cyan(`\n📊 Analyzing project structure: ${srcPath}\n`))
+
+  const allFiles = findAllFiles(srcPath, {
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".css", ".scss"],
+  })
+  const tsFiles = allFiles.filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"))
+  const cssFiles = allFiles.filter((f) => f.endsWith(".css") || f.endsWith(".scss"))
+  const totalLines = allFiles.reduce((acc, f) => acc + countLines(f), 0)
+
+  // Component analysis
+  const componentFiles = findComponentFiles(srcPath)
+  const importMap = analyzeImports(srcPath, componentFiles)
+
+  let totalImports = 0
+  let externalDeps = new Set()
+  for (const [, imports] of importMap) {
+    totalImports += imports.length
+    for (const imp of imports) {
+      if (imp.includes("/") || imp.includes(".")) continue // skip relative
+      externalDeps.add(imp)
+    }
+  }
+
+  const anyCount = allFiles.filter((f) => {
+    try {
+      const content = readFileSync(f, "utf-8")
+      return content.includes(": any") || content.includes("as any")
+    } catch {
+      return false
+    }
+  }).length
+
+  console.log(chalk.cyan(`\n  📊 Project Stats:\n`))
+  console.log(`     ${chalk.bold("Total files:")}     ${allFiles.length}`)
+  console.log(`     ${chalk.bold("TypeScript:")}      ${tsFiles.length}`)
+  console.log(`     ${chalk.bold("CSS/SCSS:")}        ${cssFiles.length}`)
+  console.log(`     ${chalk.bold("Total lines:")}     ${totalLines}`)
+  console.log(`     ${chalk.bold("Components:")}      ${componentFiles.length}`)
+  console.log(`     ${chalk.bold("Total imports:")}   ${totalImports}`)
+  console.log(`     ${chalk.bold("External deps:")}   ${externalDeps.size}`)
+  console.log(
+    `     ${chalk.bold("Files with any:")}  ${anyCount} ${anyCount > 0 ? chalk.red("⚠️") : chalk.green("✅")}`
+  )
+  console.log("")
+
+  // Top external deps
+  const sortedDeps = [...externalDeps].sort()
+  if (sortedDeps.length > 0) {
+    console.log(chalk.gray(`  External dependencies:\n`))
+    for (const dep of sortedDeps.slice(0, 15)) {
+      console.log(`     📦 ${dep}`)
+    }
+    if (sortedDeps.length > 15) {
+      console.log(chalk.gray(`     ... and ${sortedDeps.length - 15} more\n`))
+    }
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function countLines(file) {
+  try {
+    return readFileSync(file, "utf-8").split("\n").length
+  } catch {
+    return 0
+  }
+}

package/src/commands/figma.js

@@ -1,11 +1,11 @@
-import { writeFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { generateFigmaPrompt } from "../generators/figma-prompt.js";
+import { writeFileSync, existsSync, mkdirSync } from "fs"
+import { join } from "path"
+import chalk from "chalk"
+import inquirer from "inquirer"
+import { generateFigmaPrompt } from "../generators/figma-prompt.js"
 
 export async function figma() {
-  console.log(chalk.cyan("\n🎨 Generador de Prompt para Figma\n"));
+  console.log(chalk.cyan("\n🎨 Generador de Prompt para Figma\n"))
 
   const answers = await inquirer.prompt([
     {
@@ -44,20 +44,20 @@ export async function figma() {
       message: "¿Incluir anti-patrones a evitar?",
       default: true,
     },
-  ]);
+  ])
 
-  const promptContent = generateFigmaPrompt(answers);
+  const promptContent = generateFigmaPrompt(answers)
 
   // Guardar en docs/PROMPTS/
-  const promptsDir = join(process.cwd(), "docs", "PROMPTS");
+  const promptsDir = join(process.cwd(), "docs", "PROMPTS")
   if (!existsSync(promptsDir)) {
-    mkdirSync(promptsDir, { recursive: true });
+    mkdirSync(promptsDir, { recursive: true })
   }
 
-  const outputPath = join(promptsDir, "figma-prompt.md");
-  writeFileSync(outputPath, promptContent, "utf-8");
+  const outputPath = join(promptsDir, "figma-prompt.md")
+  writeFileSync(outputPath, promptContent, "utf-8")
 
-  console.log(chalk.green(`\n✅ Prompt Figma generado:`));
-  console.log(chalk.cyan(`   ${outputPath}\n`));
-  console.log(promptContent);
+  console.log(chalk.green(`\n✅ Prompt Figma generado:`))
+  console.log(chalk.cyan(`   ${outputPath}\n`))
+  console.log(promptContent)
 }