openprompt-lang 0.3.0 → 0.4.0

package/src/ai/prompt-builder.js

@@ -0,0 +1,184 @@
+import { readFileSync } from "fs"
+import { join } from "path"
+import { getLanguageIndex, getLanguagePath } from "../utils/language-loader.js"
+
+export function buildPrompt(description, options = {}) {
+  const langId = options.lang || "react"
+  const index = getLanguageIndex(langId)
+  const profile = options.profile || "mid"
+
+  const relevantTemplates = findRelevantTemplates(description, index)
+
+  let templateExamples = ""
+  if (relevantTemplates.length > 0) {
+    templateExamples = "\n\n## Relevant templates for reference:\n\n"
+    for (const t of relevantTemplates.slice(0, 3)) {
+      const content = loadTemplateContent(t, langId)
+      if (content) {
+        templateExamples += `### ${t.id}\n\`\`\`tsx\n${content.slice(0, 800)}\n\`\`\`\n\n`
+      }
+    }
+  }
+
+  const kind = detectKind(description)
+  const componentName = options.name || suggestName(description, kind)
+
+  const systemPrompt = getSystemPrompt(langId, profile)
+
+  const userPrompt = [
+    `Generate a ${langId} component based on this description:`,
+    "",
+    description,
+    "",
+    `## Requirements:`,
+    `- Name: ${componentName}`,
+    `- Kind: ${kind}`,
+    `- Profile: ${profile}`,
+    `- Include @use() annotation at the top with the tags you use`,
+    `- Include @kind, @props (if component), @contract (if hook/service), @limit, @test annotations`,
+    templateExamples,
+    `## Language: ${langId}`,
+    `## Profile rules:`,
+    ...getProfileRules(profile),
+    "",
+    `Return ONLY the code, no markdown wrapping or explanation.`,
+  ].join("\n")
+
+  return { componentName, kind, systemPrompt, userPrompt, prompt: userPrompt }
+}
+
+function findRelevantTemplates(description, index) {
+  if (!index?.templates) return []
+
+  const desc = description.toLowerCase()
+  const keywords = desc.split(/\W+/).filter(Boolean)
+
+  const scored = index.templates.map((t) => {
+    const text = [t.name, t.description, ...(t.tags || []), t.category].join(" ").toLowerCase()
+    const score = keywords.reduce((sum, kw) => sum + (text.includes(kw) ? 1 : 0), 0)
+    return { template: t, score }
+  })
+
+  return scored
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((s) => s.template)
+}
+
+function loadTemplateContent(template, langId) {
+  try {
+    const langPath = getLanguagePath(langId)
+    if (!langPath) return null
+    const filePath = join(langPath, template.file)
+    return readFileSync(filePath, "utf-8")
+  } catch {
+    return null
+  }
+}
+
+function detectKind(description) {
+  const desc = description.toLowerCase()
+  const words = desc.split(/\W+/).filter(Boolean)
+  const wordSet = new Set(words)
+
+  // Order matters: more specific matches first
+  if (hasAny(words, ["page", "screen", "view", "route"])) return "page"
+  if (hasAny(words, ["hook", "auth", "session", "fetch", "query", "mutation"])) return "hook"
+  if (hasAny(words, ["service", "api", "client", "http", "axios"])) return "service"
+  if (hasAny(words, ["store", "context", "provider"])) return "store"
+  if (hasAny(words, ["layout", "sidebar", "navbar", "footer", "shell"])) return "layout"
+  if (hasAny(words, ["button", "input", "card", "modal", "dialog", "form", "table"]))
+    return "component"
+
+  return "component"
+}
+
+function hasAny(words, targets) {
+  return targets.some((t) => words.includes(t))
+}
+
+const STOP_WORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "with",
+  "for",
+  "and",
+  "or",
+  "to",
+  "of",
+  "in",
+  "on",
+  "at",
+  "by",
+  "is",
+  "it",
+])
+
+function suggestName(description, kind) {
+  const words = description
+    .split(/\W+/)
+    .filter(Boolean)
+    .filter((w) => !STOP_WORDS.has(w.toLowerCase()))
+    .slice(0, 3)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+
+  if (words.length === 0) words.push("Component")
+
+  const prefixes = {
+    hook: "use",
+    component: "",
+    page: "",
+    service: "create",
+    store: "use",
+    layout: "",
+    util: "",
+    type: "",
+  }
+
+  const baseName = words.join("")
+  const prefix = prefixes[kind] || ""
+
+  if (prefix) return `${prefix}${baseName}`
+  if (baseName.endsWith("Component") || baseName.endsWith("Page") || kind === "hook")
+    return baseName
+  const suffix = kind === "hook" ? "" : kind === "page" ? "" : "Component"
+  return `${baseName}${suffix}`
+}
+
+function getSystemPrompt(langId, profile) {
+  const base = `You are an expert ${langId} developer using openPrompt-Lang annotations.`
+
+  const profilePrompts = {
+    senior:
+      "Generate clean, production-ready code with strict TypeScript, no any types, and full annotations.",
+    mid: "Generate balanced code with TypeScript and basic annotations.",
+    junior: "Generate simple, well-documented code with plenty of comments and guidance.",
+  }
+
+  return `${base}\n\n${profilePrompts[profile] || profilePrompts.mid}`
+}
+
+function getProfileRules(profile) {
+  const rules = {
+    senior: [
+      "- No 'any' types — use 'unknown' + type narrowing",
+      "- Every file must have @use(), @kind, @limit annotations",
+      "- Extract interfaces/types to separate files if > 5 props",
+      "- Include error boundaries for components",
+    ],
+    mid: [
+      "- Prefer specific types over 'any'",
+      "- Include @kind and @props annotations",
+      "- Basic error handling",
+    ],
+    junior: [
+      "- Add explanatory comments for complex logic",
+      "- Include PropTypes or basic type validation",
+      "- Add TODO comments for future improvements",
+      "- Add console.error in catch blocks",
+    ],
+  }
+
+  return rules[profile] || rules.mid
+}

package/src/ai/providers.js

@@ -0,0 +1,247 @@
+// ─── AI Provider abstraction for openPrompt-Lang ────────────────────────────
+// Each provider must implement: generate(prompt, options) => Promise<string>
+
+const PROVIDERS = {}
+
+export function registerProvider(name, provider) {
+  PROVIDERS[name] = provider
+}
+
+export function getProvider(name) {
+  return PROVIDERS[name]
+}
+
+export function listProviders() {
+  return Object.keys(PROVIDERS)
+}
+
+export async function generateCode(prompt, options = {}) {
+  const providerName = options.provider || "check env"
+  const resolvedProvider = resolveProvider(providerName)
+
+  const provider = getProvider(resolvedProvider)
+  if (!provider) {
+    throw new Error(`Provider "${resolvedProvider}" not available. Install it first.`)
+  }
+
+  return provider.generate(prompt, options)
+}
+
+function resolveProvider(preference) {
+  if (preference !== "check env") return preference
+
+  if (process.env.OPENAI_API_KEY || process.env.OPENPROMPT_API_KEY) return "openai"
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic"
+  if (process.env.OLLAMA_HOST) return "ollama"
+
+  return "none"
+}
+
+// ─── Provider: Ollama (local, free) ─────────────────────────────────────────
+
+registerProvider("ollama", {
+  name: "Ollama",
+  description: "Local LLM via Ollama (free, no API key needed)",
+  requiresKey: false,
+
+  async generate(prompt, options = {}) {
+    const host = process.env.OLLAMA_HOST || "http://localhost:11434"
+    const model = options.model || "codellama:7b"
+
+    try {
+      const resp = await fetch(`${host}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          prompt,
+          stream: false,
+          options: {
+            temperature: options.temperature ?? 0.3,
+            max_tokens: options.maxTokens ?? 2048,
+          },
+        }),
+      })
+
+      if (!resp.ok) throw new Error(`Ollama error: ${resp.status}`)
+
+      const data = await resp.json()
+      return data.response || ""
+    } catch (err) {
+      throw new Error(`Ollama request failed: ${err.message}`)
+    }
+  },
+})
+
+// ─── Provider: OpenAI ────────────────────────────────────────────────────────
+
+registerProvider("openai", {
+  name: "OpenAI",
+  description: "GPT-4o / GPT-4 / GPT-3.5 via OpenAI API",
+  requiresKey: true,
+
+  async generate(prompt, options = {}) {
+    const apiKey = process.env.OPENAI_API_KEY || process.env.OPENPROMPT_API_KEY
+    if (!apiKey) throw new Error("OPENAI_API_KEY or OPENPROMPT_API_KEY not set")
+
+    const model = options.model || "gpt-4o"
+    const apiUrl = options.apiUrl || "https://api.openai.com/v1/chat/completions"
+
+    try {
+      const resp = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            {
+              role: "system",
+              content:
+                options.systemPrompt ||
+                "You are an expert TypeScript/React developer. Generate clean, production-ready code with openPrompt-Lang annotations.",
+            },
+            { role: "user", content: prompt },
+          ],
+          temperature: options.temperature ?? 0.3,
+          max_tokens: options.maxTokens ?? 4096,
+        }),
+      })
+
+      if (!resp.ok) {
+        const err = await resp.text()
+        throw new Error(`OpenAI error ${resp.status}: ${err}`)
+      }
+
+      const data = await resp.json()
+      return data.choices?.[0]?.message?.content || ""
+    } catch (err) {
+      throw new Error(`OpenAI request failed: ${err.message}`)
+    }
+  },
+})
+
+// ─── Provider: Anthropic ─────────────────────────────────────────────────────
+
+registerProvider("anthropic", {
+  name: "Anthropic",
+  description: "Claude 3.5 Sonnet / Haiku via Anthropic API",
+  requiresKey: true,
+
+  async generate(prompt, options = {}) {
+    const apiKey = process.env.ANTHROPIC_API_KEY
+    if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set")
+
+    const model = options.model || "claude-sonnet-4-20250514"
+    const apiUrl = "https://api.anthropic.com/v1/messages"
+
+    try {
+      const resp = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: options.maxTokens ?? 4096,
+          system:
+            options.systemPrompt ||
+            "You are an expert TypeScript/React developer. Generate clean, production-ready code with openPrompt-Lang annotations.",
+          messages: [{ role: "user", content: prompt }],
+        }),
+      })
+
+      if (!resp.ok) {
+        const err = await resp.text()
+        throw new Error(`Anthropic error ${resp.status}: ${err}`)
+      }
+
+      const data = await resp.json()
+      return data.content?.[0]?.text || ""
+    } catch (err) {
+      throw new Error(`Anthropic request failed: ${err.message}`)
+    }
+  },
+})
+
+// ─── Provider: Mock (for testing / dry-run) ──────────────────────────────────
+
+registerProvider("mock", {
+  name: "Mock",
+  description: "Local mock that returns a placeholder component (no API needed)",
+  requiresKey: false,
+
+  async generate(prompt, options = {}) {
+    const componentName = options.componentName || "GeneratedComponent"
+
+    return `// @generated by openPrompt-Lang ai-gen (mock provider)
+// @use(@kind, @props, @limit)
+// @kind(component)
+// @props({ variant: "'primary' | 'secondary'", size: "'sm' | 'md' | 'lg'" })
+// @limit(lines: 60)
+// @test(coverage: 80)
+
+import { type VariantProps, cva } from "class-variance-authority"
+import { cn } from "@/lib/utils"
+
+const ${componentName}Variants = cva("", {
+  variants: {
+    variant: {
+      primary: "bg-blue-500 text-white hover:bg-blue-600",
+      secondary: "bg-gray-100 text-gray-900 hover:bg-gray-200",
+    },
+    size: {
+      sm: "px-2 py-1 text-sm",
+      md: "px-4 py-2 text-base",
+      lg: "px-6 py-3 text-lg",
+    },
+  },
+  defaultVariants: {
+    variant: "primary",
+    size: "md",
+  },
+})
+
+export interface ${componentName}Props
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof ${componentName}Variants> {}
+
+export function ${componentName}({
+  className,
+  variant,
+  size,
+  ...props
+}: ${componentName}Props) {
+  return (
+    <div
+      className={cn(${componentName}Variants({ variant, size }), className)}
+      {...props}
+    />
+  )
+}
+`
+  },
+})
+
+// ─── No provider available ──────────────────────────────────────────────────
+
+registerProvider("none", {
+  name: "None",
+  description: "No AI provider configured",
+  requiresKey: false,
+
+  async generate() {
+    throw new Error(
+      "No AI provider configured.\n\n" +
+        "Set one of:\n" +
+        "  OPENAI_API_KEY     → uses GPT-4o\n" +
+        "  ANTHROPIC_API_KEY  → uses Claude 3.5\n" +
+        "  OLLAMA_HOST        → uses local Ollama (default: http://localhost:11434)\n\n" +
+        "Or use --provider mock for a dry-run.\n"
+    )
+  },
+})

package/src/annotations/registry.js

@@ -0,0 +1,39 @@
+import { readFileSync } from "fs"
+import { createRequire } from "module"
+import { fileURLToPath } from "url"
+import { dirname, join } from "path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const BUILTIN_TAGS = JSON.parse(readFileSync(join(__dirname, "tags.json"), "utf-8"))
+
+export function getBuiltinTags() {
+  return [...BUILTIN_TAGS]
+}
+
+export function getAnnotationTags(langId, projectConfig) {
+  const tags = new Set(BUILTIN_TAGS)
+
+  // Load from language module if available
+  if (langId) {
+    try {
+      const require = createRequire(import.meta.url)
+      const modPath = require.resolve(`../templates/langs/${langId}/MODULE.json`)
+      const mod = JSON.parse(readFileSync(modPath, "utf-8"))
+      if (mod.annotationTags) {
+        for (const t of mod.annotationTags) tags.add(t)
+      }
+    } catch {}
+  }
+
+  // Load from project config
+  if (projectConfig?.annotations?.customTags) {
+    for (const t of projectConfig.annotations.customTags) tags.add(t)
+  }
+
+  return [...tags]
+}
+
+export function makeTagPattern(tags) {
+  const escaped = tags.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+  return new RegExp(`^\\s*@(${escaped.join("|")})\\(`)
+}

package/src/annotations/tags.json

@@ -0,0 +1,24 @@
+[
+  "use",
+  "kind",
+  "contract",
+  "props",
+  "state",
+  "limit",
+  "forbidden",
+  "compose",
+  "deps",
+  "platform",
+  "scope",
+  "test",
+  "meta",
+  "pattern",
+  "learn-error",
+  "goodPractice",
+  "badPractice",
+  "teachMe",
+  "template",
+  "source",
+  "reuse",
+  "extracted"
+]

package/src/commands/ai-gen.js

@@ -0,0 +1,161 @@
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from "fs"
+import { join, relative } from "path"
+import chalk from "chalk"
+import inquirer from "inquirer"
+import { getLanguageIndex } from "../utils/language-loader.js"
+import { buildPrompt } from "../ai/prompt-builder.js"
+import { generateCode, listProviders, getProvider } from "../ai/providers.js"
+
+export async function aiGen(options) {
+  const cwd = process.cwd()
+  const langId = options.lang || "react"
+  const profile = options.profile || "mid"
+  const provider =
+    options.provider ||
+    (process.env.OPENAI_API_KEY ? "openai" : process.env.ANTHROPIC_API_KEY ? "anthropic" : "mock")
+
+  console.log(chalk.cyan("\n🤖 openPrompt-Lang AI Generator\n"))
+  console.log(chalk.gray(`  Provider: ${provider}`))
+  console.log(chalk.gray(`  Language: ${langId}`))
+  console.log(chalk.gray(`  Profile:  ${profile}\n`))
+
+  // Get description
+  let description = options.description
+  if (!description) {
+    console.log(chalk.blue("  Describe what you want to generate:"))
+    const resp = await inquirer.prompt([
+      {
+        type: "input",
+        name: "description",
+        message: "Description:",
+        validate: (input) => input.trim().length >= 10 || "Describe in at least 10 characters",
+      },
+    ])
+    description = resp.description
+  }
+
+  // Build prompt
+  const promptResult = buildPrompt(description, {
+    lang: langId,
+    profile,
+    name: options.name,
+  })
+
+  console.log(chalk.gray(`\n  Detected kind: ${promptResult.kind}`))
+  console.log(chalk.gray(`  Suggested name: ${promptResult.componentName}`))
+
+  if (options.verbose) {
+    console.log(chalk.gray("\n  Prompt preview:\n"))
+    console.log(chalk.gray(promptResult.prompt.slice(0, 600) + "...\n"))
+  }
+
+  // Generate
+  console.log(chalk.blue(`\n  Generating with ${provider}...\n`))
+
+  let code
+  try {
+    code = await generateCode(promptResult.prompt, {
+      provider,
+      componentName: promptResult.componentName,
+      systemPrompt: promptResult.systemPrompt,
+      temperature: options.temperature ?? 0.3,
+      maxTokens: options.maxTokens ?? 4096,
+    })
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ Generation failed: ${err.message}\n`))
+    console.log(
+      chalk.gray("  Available providers:"),
+      chalk.cyan(
+        listProviders()
+          .filter((p) => p !== "none")
+          .join(", ")
+      )
+    )
+    console.log(chalk.gray("  Try: --provider mock (for dry-run without API key)\n"))
+    return
+  }
+
+  // Clean code (remove markdown code fences if present)
+  code = cleanGeneratedCode(code)
+
+  // Preview
+  console.log(chalk.green("  ✅ Generated:\n"))
+  console.log(code.slice(0, 500) + (code.length > 500 ? "\n  ...\n" : "\n"))
+
+  // Confirm and write
+  const outputDir = options.output ? join(cwd, options.output) : join(cwd, "src", "components")
+
+  mkdirSync(outputDir, { recursive: true })
+  const outputFile = join(outputDir, `${promptResult.componentName}.tsx`)
+
+  if (existsSync(outputFile) && !options.force) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `File ${relative(cwd, outputFile)} exists. Overwrite?`,
+        default: false,
+      },
+    ])
+    if (!overwrite) {
+      console.log(chalk.yellow("  ⏭️  Skipped.\n"))
+      return
+    }
+  }
+
+  writeFileSync(outputFile, code, "utf-8")
+  console.log(chalk.green(`  ✅ Written: ${relative(cwd, outputFile)}\n`))
+
+  // Validate if possible
+  if (options.validate) {
+    console.log(chalk.blue("  Running validation...\n"))
+    const { lintFile } = await import("../utils/annotations.js")
+    const result = lintFile(code, true)
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow("  Validation issues:\n"))
+      for (const err of result.errors) console.log(`    ⚠️  ${err}`)
+      console.log("")
+    } else {
+      console.log(chalk.green("  ✅ Validation passed.\n"))
+    }
+  }
+
+  // Suggest next steps
+  console.log(chalk.cyan("  📋 Next steps:\n"))
+  console.log(
+    `    npx openPrompt-Lang teach ${promptResult.componentName.toLowerCase()} --lang ${langId}`
+  )
+  console.log(`    npx openPrompt-Lang qa-gen --lang ${langId}`)
+  console.log(`    npx openPrompt-Lang extract src/ --min-reuse 2\n`)
+}
+
+function cleanGeneratedCode(code) {
+  // Remove markdown code fences
+  code = code.replace(/^```[\w]*\n/gm, "")
+  code = code.replace(/```\s*$/gm, "")
+  return code.trim()
+}
+
+export async function aiProviders() {
+  const providers = listProviders()
+  console.log(chalk.cyan("\n🔌 AI Providers:\n"))
+  for (const name of providers) {
+    const p = getProvider(name)
+    const keyStatus = p.requiresKey
+      ? name === "openai"
+        ? process.env.OPENAI_API_KEY
+          ? "✅ key found"
+          : "❌ no key"
+        : name === "anthropic"
+          ? process.env.ANTHROPIC_API_KEY
+            ? "✅ key found"
+            : "❌ no key"
+          : ""
+      : "✅ no key required"
+    console.log(`  ${chalk.bold(name)} — ${p.description}`)
+    console.log(`     ${keyStatus}`)
+    console.log("")
+  }
+
+  console.log(chalk.gray("  Set provider with --provider flag or environment variables\n"))
+}