openprompt-lang 0.3.0 → 0.4.0

package/src/commands/wizard.js

@@ -0,0 +1,456 @@
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from "fs"
+import { join } from "path"
+import chalk from "chalk"
+import inquirer from "inquirer"
+import {
+  getLanguages,
+  getProjectTypes,
+  getUiStyles,
+  getExtensions,
+  getStructure,
+  getLanguageIndex,
+  getLanguagePath,
+  getTemplateErrors,
+} from "../utils/language-loader.js"
+
+const PROFILES = [
+  { name: "Senior — max control, minimal boilerplate", value: "senior" },
+  { name: "Mid — balance between speed and structure", value: "mid" },
+  { name: "Junior — more guidance and restrictions", value: "junior" },
+]
+
+const PROJECT_REQUIREMENTS = {
+  api: {
+    questions: [
+      {
+        name: "auth",
+        message: "Authentication?",
+        choices: ["none", "JWT", "Supabase", "Auth.js", "Clerk"],
+        default: "none",
+      },
+      {
+        name: "database",
+        message: "Database?",
+        choices: ["none", "SQLite", "PostgreSQL", "MongoDB", "Supabase"],
+        default: "none",
+      },
+      {
+        name: "orm",
+        message: "ORM / Query builder?",
+        choices: ["none", "Drizzle", "Prisma", "TypeORM", "Knex"],
+        default: "none",
+      },
+      {
+        name: "validation",
+        message: "Validation library?",
+        choices: ["none", "Zod", "Yup", "Joi"],
+        default: "none",
+      },
+      {
+        name: "testing",
+        message: "Testing framework?",
+        choices: ["Vitest", "Jest", "none"],
+        default: "Vitest",
+      },
+    ],
+  },
+  web: {
+    questions: [
+      {
+        name: "routing",
+        message: "Routing strategy?",
+        choices: ["React Router", "TanStack Router", "File-based (Next.js)", "none"],
+        default: "React Router",
+      },
+      {
+        name: "data-fetching",
+        message: "Data fetching?",
+        choices: ["TanStack Query", "SWR", "RTK Query", "none"],
+        default: "TanStack Query",
+      },
+      {
+        name: "state-management",
+        message: "State management?",
+        choices: ["Zustand", "Redux Toolkit", "Jotai", "Context only", "none"],
+        default: "Zustand",
+      },
+      {
+        name: "styling",
+        message: "Styling approach?",
+        choices: ["Tailwind", "CSS Modules", "Styled Components", "Vanilla CSS"],
+        default: "Tailwind",
+      },
+    ],
+  },
+  mobile: {
+    questions: [
+      {
+        name: "framework",
+        message: "Mobile framework?",
+        choices: ["React Native", "Capacitor", "Tauri"],
+        default: "Capacitor",
+      },
+      {
+        name: "navigation",
+        message: "Navigation?",
+        choices: ["React Navigation", "File-based (Expo)", "none"],
+        default: "React Navigation",
+      },
+    ],
+  },
+  desktop: {
+    questions: [
+      {
+        name: "framework",
+        message: "Desktop framework?",
+        choices: ["Tauri", "Electron"],
+        default: "Tauri",
+      },
+    ],
+  },
+  library: {
+    questions: [
+      {
+        name: "bundler",
+        message: "Bundler?",
+        choices: ["tsup", "Rollup", "Vite library mode"],
+        default: "tsup",
+      },
+      {
+        name: "publish",
+        message: "Publish target?",
+        choices: ["npm", "GitHub Packages", "none"],
+        default: "none",
+      },
+    ],
+  },
+}
+
+export async function wizard() {
+  console.log(chalk.cyan("\n🧙 openPrompt-Lang Project Wizard\n"))
+  console.log(chalk.gray("Answer the questions to generate the optimal configuration.\n"))
+
+  // Load languages dynamically from modules
+  const languages = getLanguages(true)
+  if (languages.length === 0) {
+    console.log(chalk.red("\n❌ No language modules found. Run: npx openPrompt-Lang lang list\n"))
+    return
+  }
+
+  const langChoices = languages.map((l) => ({
+    name: `${l.name} v${l.version}`,
+    value: l.id,
+  }))
+
+  // 1. Language
+  const { langId } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "langId",
+      message: "Which language/framework will you use?",
+      choices: langChoices,
+    },
+  ])
+
+  // 2. Project type
+  const projectTypes = getProjectTypes(langId)
+  const typeChoices = projectTypes
+    ? Object.entries(projectTypes).map(([key, val]) => ({
+        name: `${val.name} — ${val.description || ""}`,
+        value: key,
+      }))
+    : [{ name: "Default", value: "default" }]
+
+  const { projectType } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "projectType",
+      message: "What type of project is this?",
+      choices: typeChoices,
+    },
+  ])
+
+  // 2b. Requirements refinement
+  const refinement = await askRefinement(projectType)
+
+  // 3. UI Style (only if project type needs UI)
+  let uiStyle = "none"
+  const needsUI = projectTypes?.[projectType]?.ui !== false
+  if (needsUI) {
+    const styles = getUiStyles(langId)
+    const styleChoices = styles.map((s) => ({
+      name: s === "none" ? "None (no UI library)" : s,
+      value: s,
+    }))
+
+    const resp = await inquirer.prompt([
+      {
+        type: "list",
+        name: "uiStyle",
+        message: "Which UI library?",
+        choices: styleChoices,
+      },
+    ])
+    uiStyle = resp.uiStyle
+  }
+
+  // 4. Extensions available for this language
+  const availableExts = getExtensions(langId)
+  let extensions = []
+  if (availableExts.length > 0) {
+    const resp = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "extensions",
+        message: "Which extensions do you need?",
+        choices: availableExts.map((e) => ({ name: e.name, value: e.value })),
+      },
+    ])
+    extensions = resp.extensions
+  }
+
+  // 5. Profile
+  const { profile } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "profile",
+      message: "Developer profile?",
+      choices: PROFILES,
+    },
+  ])
+
+  // 6. Project name
+  const { projectName } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: "mi-proyecto",
+      validate: (input) => input.trim().length > 0 || "Name cannot be empty",
+    },
+  ])
+
+  // Get structure info for the scaffold suggestion
+  const structure = getStructure(langId)
+  const index = getLanguageIndex(langId)
+  const templates = index?.templates || []
+
+  // Build config
+  const config = {
+    name: projectName,
+    version: "0.1.0",
+    lenguaje: langId,
+    projectType,
+    profile,
+    stack: {
+      base: structure?.folders
+        ?.filter((f) => f.startsWith("src/") || f.startsWith("app/"))
+        .map((f) => f.split("/")[1])
+        .filter(Boolean) || ["react"],
+      extensions,
+    },
+    annotations: { enabled: true, strict: profile === "senior" },
+    ui: uiStyle !== "none" ? { style: uiStyle } : undefined,
+    docs: { commits: true, logs: true, backlog: true },
+    extractor: {
+      ignore: [".env", "*.local", "dist", "node_modules"],
+      output: "contexto.md",
+    },
+    ...(Object.keys(refinement).length > 0 && { requirements: refinement }),
+  }
+
+  // Quality gating
+  const gateWarnings = qualityGate(config, structure, templates)
+
+  // Summary
+  console.log(chalk.cyan("\n📋 Configuration summary:\n"))
+  console.log(`  ${chalk.bold("Name:")}       ${projectName}`)
+  console.log(`  ${chalk.bold("Language:")}    ${langId}`)
+  console.log(`  ${chalk.bold("Type:")}        ${projectType}`)
+  console.log(`  ${chalk.bold("UI:")}          ${uiStyle}`)
+  console.log(
+    `  ${chalk.bold("Extensions:")}  ${extensions.length > 0 ? extensions.join(", ") : "none"}`
+  )
+  console.log(`  ${chalk.bold("Profile:")}     ${profile}\n`)
+
+  for (const w of gateWarnings) {
+    console.log(chalk.yellow(`  ⚠️  ${w}`))
+  }
+
+  if (gateWarnings.length > 0) console.log("")
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Generate configuration?",
+      default: true,
+    },
+  ])
+
+  if (!confirm) {
+    console.log(chalk.yellow("\n⏹️  Wizard cancelled.\n"))
+    return
+  }
+
+  // Write files
+  const targetDir = join(process.cwd(), projectName)
+  mkdirSync(targetDir, { recursive: true })
+
+  writeFileSync(join(targetDir, "prompt-lang.json"), JSON.stringify(config, null, 2), "utf-8")
+  console.log(chalk.green(`  ✅ prompt-lang.json`))
+
+  const agentsContent = generateAgentsMd(config, structure)
+  writeFileSync(join(targetDir, "AGENTS.md"), agentsContent, "utf-8")
+  console.log(chalk.green("  ✅ AGENTS.md"))
+
+  // Post-wizard analyzer
+  postWizardReport(projectName, langId, config, templates)
+}
+
+function askRefinement(projectType) {
+  const specs = PROJECT_REQUIREMENTS[projectType]
+  if (!specs) return {}
+
+  return inquirer.prompt(
+    specs.questions.map((q) => ({
+      type: "list",
+      name: q.name,
+      message: q.message,
+      choices: q.choices,
+      default: q.default,
+    }))
+  )
+}
+
+export function qualityGate(config, structure, templates) {
+  const warnings = []
+
+  if (config.projectType === "api" && config.ui?.style && config.ui.style !== "none") {
+    warnings.push("UI library selected for an API project — you may not need it.")
+  }
+
+  if (config.profile === "senior" && config.projectType === "default") {
+    warnings.push(
+      "Senior profile with a default project type — consider specifying a type for better scaffolding."
+    )
+  }
+
+  if (config.projectType === "web" && !config.ui?.style) {
+    warnings.push(
+      "Web project without a UI library — consider adding one via component add --template."
+    )
+  }
+
+  if (config.projectType === "mobile" && config.ui?.style === "shadcn") {
+    warnings.push("shadcn/ui is not available for mobile projects.")
+  }
+
+  if (config.requirements?.testing === "none" && config.profile !== "junior") {
+    warnings.push("No testing framework selected — consider adding one.")
+  }
+
+  if (config.requirements?.database !== "none" && config.requirements?.orm === "none") {
+    warnings.push(
+      `Database (${config.requirements.database}) selected without an ORM — consider Drizzle or Prisma.`
+    )
+  }
+
+  if (templates && templates.length === 0) {
+    warnings.push(
+      "No templates available for this language module — teach command will have limited content."
+    )
+  }
+
+  return warnings
+}
+
+function postWizardReport(projectName, langId, config, templates) {
+  console.log(chalk.cyan("\n📊 Post-wizard analysis:\n"))
+
+  // Suggested templates to explore
+  const suggestedTemplates = templates
+    ? templates
+        .filter((t) => t.hasTeachMe)
+        .slice(0, 4)
+        .map((t) => `  • npx openPrompt-Lang teach ${t.id} --lang ${langId}`)
+    : []
+
+  console.log(chalk.bold("  🎯 Commands to run next:\n"))
+  console.log(`     cd ${projectName}`)
+  console.log(`     npx openPrompt-Lang scaffold folders ${langId}`)
+  if (config.requirements?.testing && config.requirements.testing !== "none") {
+    console.log(`     npx openPrompt-Lang qa-gen --lang ${langId} --output src/__tests__`)
+  }
+  console.log("")
+
+  if (suggestedTemplates.length > 0) {
+    console.log(chalk.bold("  📚 Templates available with @teachMe:\n"))
+    for (const cmd of suggestedTemplates) console.log(cmd)
+    console.log("")
+  }
+
+  // Template coverage
+  if (templates) {
+    const practiceCounts = countPractices(langId, templates)
+    console.log(chalk.bold("  📈 Module stats:\n"))
+    console.log(`     Templates:     ${templates.length}`)
+    console.log(`     @teachMe:      ${templates.filter((t) => t.hasTeachMe).length}`)
+    console.log(`     @goodPractice: ${practiceCounts.good}`)
+    console.log(`     @badPractice:  ${practiceCounts.bad}`)
+    const errorCount = getTemplateErrors(langId).length
+    console.log(`     Learned errors: ${errorCount}\n`)
+  }
+
+  console.log(chalk.cyan(`  ✅ Done. Happy coding!\n`))
+}
+
+export function generateAgentsMd(config, structure) {
+  const uiNote =
+    config.ui?.style && config.ui.style !== "none" ? `- UI Library: ${config.ui.style}\n` : ""
+
+  const foldersNote = structure?.folders?.length
+    ? `\n## Structure\n${structure.folders.map((f) => `- ${f}/`).join("\n")}\n`
+    : ""
+
+  return `# AGENTS.md — Context for AI
+
+## Project: ${config.name}
+## Stack
+- Language: ${config.lenguaje}
+- Profile: ${config.profile}
+${uiNote}${config.stack.extensions.length > 0 ? config.stack.extensions.map((e) => `- ${e}`).join("\n") : ""}
+
+## Conventions
+- Framework: openPrompt-Lang (@kind, @contract, @limit annotations)
+- NO any types
+- NO exceed line limits without refactoring
+- Annotations must declare @use() at file start
+- Run validation before every commit
+- Search templates: npx openPrompt-Lang search <query>
+- Learn from templates: npx openPrompt-Lang teach <template-id>
+
+## References
+- PromptLang syntax: docs/SYNTAX.md
+- Methodology: docs/referencia-metodologia/
+- Templates: src/templates/langs/${config.lenguaje}/INDEX.json
+${foldersNote}`
+}
+
+export function countPractices(langId, templates) {
+  const langPath = getLanguagePath(langId)
+  let good = 0
+  let bad = 0
+
+  for (const t of templates) {
+    if (!t.file || !langPath) continue
+    try {
+      const filePath = join(langPath, t.file)
+      const content = readFileSync(filePath, "utf-8")
+      if (content.includes("@goodPractice")) good++
+      if (content.includes("@badPractice")) bad++
+    } catch {}
+  }
+
+  return { good, bad }
+}

package/src/generators/figma-prompt.js

@@ -1,14 +1,18 @@
 export function generateFigmaPrompt(answers) {
-  const { projectType, screens, mobileFirst, style, includeAntiPatterns } = answers;
-  const screenList = screens.split(",").map((s) => s.trim());
+  const { projectType, screens, mobileFirst, style, includeAntiPatterns } = answers
+  const screenList = screens.split(",").map((s) => s.trim())
 
   const styleMap = {
-    "Minimalista corporativo": "minimalista, profesional, colores neutros con acento azul oscuro, tipografía sans-serif limpia, espaciado generoso",
-    "Moderno vibrante": "moderno, atrevido, gradientes sutiles, colores vibrantes (púrpura/cian), micro-interacciones, glassmorphism ligero",
-    "Oscuro (dark mode)": "dark mode first, fondo gris oscuro (#0f0f0f), acentos en verde/azul neón, contrastes altos, sombras sutiles",
-    "Claro y limpio": "claro, fondos blancos/gris claro, mucho espacio negativo, bordes suaves, iconos lineales, tipografía elegante",
-    "Personalizado": style,
-  };
+    "Minimalista corporativo":
+      "minimalista, profesional, colores neutros con acento azul oscuro, tipografía sans-serif limpia, espaciado generoso",
+    "Moderno vibrante":
+      "moderno, atrevido, gradientes sutiles, colores vibrantes (púrpura/cian), micro-interacciones, glassmorphism ligero",
+    "Oscuro (dark mode)":
+      "dark mode first, fondo gris oscuro (#0f0f0f), acentos en verde/azul neón, contrastes altos, sombras sutiles",
+    "Claro y limpio":
+      "claro, fondos blancos/gris claro, mucho espacio negativo, bordes suaves, iconos lineales, tipografía elegante",
+    Personalizado: style,
+  }
 
   const prompt = `> [!example] Prompt generado por openPrompt-Lang
 > \`\`\`markdown
@@ -34,12 +38,16 @@ export function generateFigmaPrompt(answers) {
 > - Zonas táctiles: mínimo \`h-10 w-10\` en mobile
 > - Estados: loading, empty, error, success para cada vista
 >
-> ${includeAntiPatterns ? `## Anti-patrones (Prohibido)
+> ${
+    includeAntiPatterns
+      ? `## Anti-patrones (Prohibido)
 > - ❌ Tamaños absolutos (h-[500px], w-[300px])
 > - ❌ Posicionamiento absoluto para layout (usar flex/grid)
 > - ❌ CSS personalizado o modules
 > - ❌ Componentes de más de 120 líneas
-> - ❌ Mezclar lógica de negocio en componentes de presentación` : ""}
+> - ❌ Mezclar lógica de negocio en componentes de presentación`
+      : ""
+  }
 >
 > ## Lista de Pantallas
 > ${screenList.map((s, i) => `${i + 1}. **${s}:** Describir componentes principales y flujo`).join("\n")}
@@ -50,7 +58,7 @@ export function generateFigmaPrompt(answers) {
 > - Estados visuales (loading, empty, error) para cada componente crítico
 > - Sugerencia de estructura de carpetas
 > \`\`\`
-`;
+`
 
-  return prompt;
+  return prompt
 }

package/src/language-service/plugin.cjs

@@ -0,0 +1,94 @@
+var builtinTags = [
+  "use",
+  "kind",
+  "contract",
+  "props",
+  "state",
+  "limit",
+  "forbidden",
+  "compose",
+  "deps",
+  "platform",
+  "scope",
+  "test",
+  "meta",
+  "pattern",
+  "learn-error",
+]
+
+function makeTagPattern(tags) {
+  var escaped = tags.map(function (t) {
+    return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  })
+  return new RegExp("^\\s*@(" + escaped.join("|") + ")\\(")
+}
+
+function create(typescript) {
+  var tagPattern = makeTagPattern(builtinTags)
+
+  return {
+    create: function (info) {
+      var proxy = Object.create(null)
+      var oldLS = info.languageService
+
+      function isAnnotationLine(line) {
+        return tagPattern.test(line.trim())
+      }
+
+      proxy.getSemanticDiagnostics = function (fileName) {
+        var original = oldLS.getSemanticDiagnostics(fileName)
+        if (!original || !original.length) return original
+
+        var sourceFile = info.project.getSourceFile(fileName)
+        if (!sourceFile) return original
+
+        var text = sourceFile.text || ""
+        var lines = text.split("\n")
+
+        return original.filter(function (diag) {
+          if (diag.start === undefined) return true
+          var lineIndex = 0
+          var pos = 0
+          while (pos < diag.start && lineIndex < lines.length) {
+            pos += lines[lineIndex].length + 1
+            lineIndex++
+          }
+          return !isAnnotationLine(lines[lineIndex] || "")
+        })
+      }
+
+      proxy.getQuickInfoAtPosition = function (fileName, position) {
+        var sourceFile = info.project.getSourceFile(fileName)
+        if (!sourceFile) return undefined
+
+        var text = sourceFile.text || ""
+        var lines = text.split("\n")
+        var pos = 0
+        for (var i = 0; i < lines.length; i++) {
+          if (position >= pos && position < pos + lines[i].length + 1) {
+            var line = lines[i].trim()
+            var match = line.match(tagPattern)
+            if (match) {
+              return {
+                displayParts: [{ text: "promptlang annotation", kind: "keyword" }],
+                documentation: [
+                  {
+                    text: "@" + match[1] + " — annotation for AI-assisted development",
+                    kind: "documentation",
+                  },
+                ],
+              }
+            }
+            break
+          }
+          pos += lines[i].length + 1
+        }
+        return oldLS.getQuickInfoAtPosition(fileName, position)
+      }
+
+      return proxy
+    },
+  }
+}
+
+module.exports = { create }

package/src/language-service/plugin.d.ts

@@ -0,0 +1,6 @@
+export function create(typescript: {
+  createLanguageService: (host: any) => any
+  flattenDiagnosticMessageText: (text: any) => string
+}): {
+  create: (info: { languageService: any; project: any }) => any
+}