openprompt-lang 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openprompt-lang",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "PromptLang CLI — Context Engine de anotaciones para desarrollo asistido por IA",
   "type": "module",
   "main": "./bin/cli.js",
@@ -13,24 +13,7 @@
   },
   "files": [
     "bin/",
-    "src/cli/",
-    "src/commands/",
-    "src/utils/",
-    "src/ai/",
-    "src/annotations/",
-    "src/generators/",
-    "src/language-service/",
-    "src/ts-transformer/",
-    "src/vite-plugin/",
-    "src/mcp-server.js",
-    "src/mcp-plan-server.js",
-    "src/mcp-shared-state.js",
-    "src/mcp-session.js",
-    "src/mcp-workflow.js",
-    "src/templates/langs/",
-    "src/templates/knowledge-repo/",
-    "src/templates/semantic-index.json",
-    "src/templates/scripts/",
+    "src/",
     "schemas/",
     "docs/",
     "scaffolds/",

package/src/commands/init-core.js

@@ -1,227 +1,27 @@
 // @use(kind, contract, limit)
 // @kind(feature)
-// @contract(in: options -> out: baseDir, sideEffect: init + lanza opencode modo plan)
+// @contract(in: options -> out: baseDir, sideEffect: init base + handoff prompt)
 // @limit(lines: 300)
 
-import { writeFileSync, readFileSync, existsSync, mkdirSync, cpSync } from "fs"
-import { join, dirname } from "path"
-import { fileURLToPath } from "url"
-import { execSync, spawn } from "child_process"
-import { homedir } from "os"
+import { writeFileSync, existsSync, mkdirSync } from "fs"
+import { join } from "path"
 import chalk from "chalk"
 import inquirer from "inquirer"
-import {
-  validatePreInit,
-  selectStack,
-  selectFullStack,
-  generateAgentsMd,
-  setupOpencodeConfig,
-  printPostInitSummary,
-  DESCRIPTIVE_SCRIPTS,
-  PROFILES,
-  generateFrameworkMd,
-} from "./init-helpers.js"
+import { validatePreInit } from "./init-helpers.js"
 import { initExisting } from "./init-existing.js"
-import { setMode } from "../mcp-shared-state.js"
-
-function getKnowledgeIndexPath() {
-  const __dirname = dirname(fileURLToPath(import.meta.url))
-  return join(__dirname, "..", "templates", "knowledge-repo", "processed", "index", "index.json")
-}
-
-// ──────────────── Filtro de libros por contexto ────────────────
-
-function getDomainFromDescription(description) {
-  const lower = description.toLowerCase()
-  const domainHints = {
-    ecommerce: [
-      "ecommerce",
-      "e-commerce",
-      "tienda",
-      "productos",
-      "carrito",
-      "pagos",
-      "checkout",
-      "ventas",
-      "shop",
-      "store",
-    ],
-    saas: [
-      "saas",
-      "suscripci",
-      "subscription",
-      "workspace",
-      "tenant",
-      "billing",
-      "planes",
-      "pricing",
-    ],
-    mobile: ["mvil", "mobile", "app", "capacitor", "ionic", "pwa", "android", "ios"],
-    api: ["api", "rest", "graphql", "backend", "microservicio", "endpoint", "webhook"],
-    admin: ["admin", "dashboard", "panel", "gestin", "crud", "administrador", "reportes"],
-    blog: ["blog", "artculos", "cms", "contenido", "post"],
-  }
-
-  for (const [domain, keywords] of Object.entries(domainHints)) {
-    if (keywords.some((kw) => lower.includes(kw))) return domain
-  }
-  return null
-}
-
-const DOMAIN_BOOK_MAP = {
-  ecommerce: ["stripe-docs", "supabase-docs", "react-patterns"],
-  saas: ["supabase-docs", "stripe-docs", "microservicios-spring"],
-  mobile: ["capacitorjs-docs", "ionic-docs"],
-  api: ["api-rest-design", "backend-nodejs"],
-  admin: ["react-patterns"],
-  blog: ["react-patterns"],
-}
-
-async function selectBooksFilteredByContext(domain, interactive) {
-  if (!interactive) return []
-
-  const indexPath = getKnowledgeIndexPath()
-  if (!existsSync(indexPath)) return []
-
-  try {
-    const catalog = JSON.parse(readFileSync(indexPath, "utf-8"))
-    const pdfs = catalog.pdfs || catalog.books || []
-    if (pdfs.length === 0) return []
-
-    const suggestedBooks = DOMAIN_BOOK_MAP[domain] || []
-    const suggestedNames = suggestedBooks
-
-    console.log(chalk.cyan(`\n📚 Biblioteca de conocimiento filtrada por contexto`))
-    if (domain) {
-      console.log(chalk.gray(`   Dominio detectado: ${domain}`))
-      console.log(
-        chalk.gray(
-          `   Libros sugeridos: ${suggestedNames.length > 0 ? suggestedNames.join(", ") : "ninguno específico"}`
-        )
-      )
-    }
-
-    const { action } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "action",
-        message: chalk.cyan("¿Activar conocimiento para la IA en este proyecto?"),
-        choices: [
-          {
-            name: `Sí — instalar biblioteca filtrada por contexto (${Math.max(suggestedNames.length, 1)} libros recomendados)`,
-            value: "filtered",
-          },
-          { name: "Seleccionar manualmente", value: "select" },
-          { name: "No — omitir por ahora", value: "none" },
-        ],
-        default: "filtered",
-      },
-    ])
-
-    if (action === "none") return []
-    if (action === "filtered") {
-      if (suggestedNames.length > 0) return suggestedNames
-      return pdfs.slice(0, 5).map((p) => p.id || p.bookId)
-    }
-
-    const { selected } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "selected",
-        message: chalk.cyan("Selecciona los libros/guas:"),
-        choices: pdfs.map((pdf) => ({
-          name: `${pdf.title || pdf.name || "Libro"} (${pdf.chapters?.length || 0} cap.)`,
-          value: pdf.id || pdf.bookId,
-        })),
-        default: suggestedNames.filter((id) => pdfs.some((p) => p.id === id || p.bookId === id)),
-      },
-    ])
-    return selected || []
-  } catch (e) {
-    console.log(chalk.yellow(`  ⚠️  Error cargando biblioteca: ${e.message}`))
-    return []
-  }
-}
-
-// ──────────────── Lanzar opencode en modo plan ────────────────
-
-function findOpencodePath() {
-  // Posibles ubicaciones de opencode
-  const candidates = [
-    "opencode",
-    join(homedir(), ".opencode", "bin", "opencode"),
-    join(homedir(), ".local", "bin", "opencode"),
-    join(homedir(), ".npm-global", "bin", "opencode"),
-  ]
-
-  for (const candidate of candidates) {
-    try {
-      execSync(`"${candidate}" --version 2>/dev/null`, { stdio: "pipe" })
-      return candidate
-    } catch {}
-  }
-  return null
-}
-
-function isOpencodeInstalled() {
-  return findOpencodePath() !== null
-}
-
-function launchOpencodePlanWizard(projectDir) {
-  console.log(chalk.cyan("\n🚀 Abriendo opencode en modo PLAN..."))
-  console.log(chalk.gray("   El asistente te guiar para definir stack, estructura y configuracin."))
-  console.log(chalk.gray("   Una vez completes el plan, se activar automticamente modo EXECUTE.\n"))
-
-  // Establecer shared state a modo plan
-  setMode("plan", projectDir)
-
-  const opencodePath = findOpencodePath()
-  if (!opencodePath) {
-    console.log(chalk.yellow("  ⚠️  opencode no encontrado."))
-    console.log(chalk.cyan("   Ejecuta: opencode .  para iniciar manualmente."))
-    return
-  }
-
-  try {
-    const child = spawn(opencodePath, ["."], {
-      cwd: projectDir,
-      stdio: "inherit",
-      env: { ...process.env, OPL_MODE: "plan" },
-    })
-
-    child.on("exit", (code) => {
-      if (code === 0) {
-        console.log(chalk.green("\n✅ Sesin de planificacin completada."))
-      } else {
-        console.log(chalk.yellow(`\n  ⚠️  opencode termin con cdigo ${code}`))
-      }
-    })
-
-    child.on("error", (err) => {
-      console.log(chalk.yellow(`\n  ⚠️  No se pudo abrir opencode: ${err.message}`))
-      console.log(chalk.cyan("   Puedes ejecutarlo manualmente: opencode ."))
-    })
-  } catch (err) {
-    console.log(chalk.yellow(`\n  ⚠️  Error lanzando opencode: ${err.message}`))
-    console.log(chalk.cyan("   Asegrate de tener opencode instalado."))
-  }
-}
-
-// ──────────────── Init principal ────────────────
 
 export async function init(options) {
   const interactive = options.interactive !== false && !!process.stdin.isTTY
   const dryRun = options.dryRun || false
-  const planOnly = options.planOnly || false
 
   if (interactive && !options.existing && !options.name && !options.preset && !options.stack) {
-    console.log(chalk.cyan("\n🧙 openPrompt-Lang — Inicializacin\n"))
+    console.log(chalk.cyan("\n🧙 openPrompt-Lang — Inicialización\n"))
 
     const { projectType } = await inquirer.prompt([
       {
         type: "list",
         name: "projectType",
-        message: "Qu tipo de proyecto?",
+        message: "¿Qué tipo de proyecto?",
         choices: [
           { name: chalk.green(" Nuevo proyecto — Crear desde cero"), value: "new" },
           {
@@ -245,8 +45,7 @@ export async function init(options) {
   }
 
   // ── Paso 1: Nombre del proyecto ──
-  const projectName = options.name || "mi-proyecto"
-  let finalName = projectName
+  let finalName = options.name || "mi-proyecto"
 
   if (!options.name && interactive) {
     const { inputName } = await inquirer.prompt([
@@ -255,7 +54,7 @@ export async function init(options) {
         name: "inputName",
         message: "Nombre del proyecto:",
         default: "mi-proyecto",
-        validate: (input) => input.trim().length > 0 || "El nombre no puede estar vaco",
+        validate: (input) => input.trim().length > 0 || "El nombre no puede estar vacío",
       },
     ])
     finalName = inputName
@@ -263,83 +62,16 @@ export async function init(options) {
 
   const finalBaseDir = join(process.cwd(), finalName)
 
-  // ── Paso 2: Descripcin del contexto ──
-  let detectedDomain = null
-  let contextDescription = ""
-
-  if (interactive) {
-    const { description } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "description",
-        message:
-          chalk.cyan(" Describe tu proyecto brevemente:\n   ") +
-          chalk.gray('(ej: "una app de e-commerce con pagos y dashboard de administracin")'),
-      },
-    ])
-
-    if (description && description.trim()) {
-      contextDescription = description.trim()
-      detectedDomain = getDomainFromDescription(contextDescription)
-      if (detectedDomain) {
-        console.log(chalk.cyan(`\n🔍 Dominio detectado: ${chalk.bold(detectedDomain)}`))
-      }
-    }
-  }
-
-  // ── Paso 3: Seleccionar libros de conocimiento filtrados ──
-  const selectedBooks = await selectBooksFilteredByContext(detectedDomain, interactive && !dryRun)
-
-  // ── Paso 4: Mostrar opciones para elegir flujo ──
-  let usePlanMode = false
-  if (interactive) {
-    const { flowChoice } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "flowChoice",
-        message: chalk.cyan(" Cmo quieres continuar?"),
-        choices: [
-          {
-            name: " Plan wizard — Abrir opencode para definir stack y estructura con asistente interactivo",
-            value: "plan",
-          },
-          { name: " Configuracin directa — Elegir stack ahora (flujo clsico)", value: "direct" },
-          { name: " Solo estructura bsica — Crear proyecto sin config extra", value: "minimal" },
-        ],
-        default: "plan",
-      },
-    ])
-    usePlanMode = flowChoice === "plan"
-    if (flowChoice === "direct") {
-      // Flujo clsico: preguntar stack ahora
-      options.interactive = true
-    }
-    if (flowChoice === "minimal") {
-      // Solo estructura bsica, sin stack ni plan
-      usePlanMode = false
-    }
-  }
-
-  // ── Dry run ──
   if (dryRun) {
     console.log(chalk.cyan("\n📋 Resumen (dry-run):\n"))
     console.log(`  📁 ${finalName}/`)
-    console.log("  ├── prompt-lang.json (bsico)")
-    console.log("  ├── AGENTS.md (bsico)")
-    console.log("  ├── .openprompt/FRAMEWORK.md")
-    console.log("  └── knowledge/ (filtrado por contexto)")
-    if (usePlanMode) {
-      console.log(chalk.cyan("\n🚀 Luego de init:"))
-      console.log("  Se abrir opencode en modo PLAN para definir stack y estructura.")
-    }
     console.log(chalk.yellow("\n⚠️  Modo dry-run — no se crearon archivos.\n"))
     return
   }
 
-  // ── Crear estructura mnima ──
-  console.log(chalk.cyan(`\n🚀 Inicializando: ${finalName}\n`))
+  // ── Crear estructura mínima ──
+  console.log(chalk.cyan(`\n🚀 Inicializando estructura base: ${finalName}\n`))
 
-  // Crear directorios bsicos
   const basicDirs = [
     ".opencode/work-context/PLANS",
     ".opencode/work-context/REPORTS",
@@ -356,93 +88,7 @@ export async function init(options) {
     console.log(`  📁 ${dir}/`)
   }
 
-  // ── Configuracin bsica de proyecto ──
-  const config = {
-    name: finalName,
-    version: "0.1.0",
-    lenguaje: "pending", // Se define en plan mode
-    stack: { base: [], extensions: [] }, // Se define en plan mode
-    profile: "senior",
-    domain: detectedDomain || null,
-    features: {},
-    workflow: {
-      strictMode: true,
-      mode: "plan",
-      autoTicket: true,
-    },
-    pipeline: {
-      "pre-commit": ["lint", "typecheck"],
-    },
-    annotations: { enabled: true, strict: true },
-    knowledge: { enabled: selectedBooks.length > 0, active: selectedBooks },
-    docs: { commits: true, logs: true, backlog: true },
-  }
-
-  writeFileSync(join(finalBaseDir, "prompt-lang.json"), JSON.stringify(config, null, 2), "utf-8")
-  console.log(chalk.green("  ✅ prompt-lang.json"))
-
-  // ── AGENTS.md bsico ──
-  const simpleAgentsMd = `# AGENTS.md — ${finalName}
-
-## Stack
-- **Lenguaje:** Por definir en modo PLAN
-- **Framework:** Por definir en modo PLAN
-- **UI:** Por definir en modo PLAN
-
-## Contexto del proyecto
-${contextDescription ? `- **Descripcin:** ${contextDescription}` : ""}
-${detectedDomain ? `- **Dominio detectado:** ${detectedDomain}` : ""}
-
-## Convenciones
-- Seguir el flujo PLAN → EXECUTE
-- El plan est en .opencode/work-context/PLANS/
-- Usar anotaciones @kind, @contract, @limit en todo archivo fuente
-
-## MCPs disponibles
-- openPrompt-plan: para planificacin (activo por defecto)
-- openPrompt: para ejecucin (se activa al completar el plan)
-`
-  writeFileSync(join(finalBaseDir, "AGENTS.md"), simpleAgentsMd, "utf-8")
-  console.log(chalk.green("  ✅ AGENTS.md"))
-
-  // ── FRAMEWORK.md mnimo ──
-  mkdirSync(join(finalBaseDir, ".openprompt"), { recursive: true })
-  writeFileSync(
-    join(finalBaseDir, ".openprompt", "FRAMEWORK.md"),
-    `# FRAMEWORK — ${finalName}
-
-## Modo dual
-- **PLAN**: Usa el MCP openPrompt-plan para definir stack, estructura y configuracin.
-- **EXECUTE**: Una vez aprobado el plan, cambia a openPrompt para implementar.
-
-## Flujo recomendado
-1. \`opl init\` → crea estructura bsica + lanza plan wizard
-2. Completa el wizard en opencode (plan mode)
-3. El plan MCP cambia automticamente a EXECUTE
-4. Usa \`analyze_project\` para empezar a implementar
-`,
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ .openprompt/FRAMEWORK.md"))
-
-  // ── .gitignore ──
-  writeFileSync(
-    join(finalBaseDir, ".gitignore"),
-    `node_modules/
-dist/
-build/
-.env
-.env.local
-*.log
-.DS_Store
-coverage/
-contexto.md
-`,
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ .gitignore"))
-
-  // ── package.json bsico ──
+  // ── package.json básico ──
   writeFileSync(
     join(finalBaseDir, "package.json"),
     JSON.stringify(
@@ -460,168 +106,22 @@ contexto.md
   )
   console.log(chalk.green("  ✅ package.json"))
 
-  // ── Docs bsicos ──
-  writeFileSync(
-    join(finalBaseDir, "docs/BACKLOG/tasks.md"),
-    `# Backlog — Tareas
-
-## TASK-001: Setup inicial
-- **Estado:** Pendiente de planificacin
-${detectedDomain ? `- **Dominio:** ${detectedDomain}` : ""}
-- **Nota:** Completa el plan en opencode antes de empezar.
-`,
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ docs/BACKLOG/tasks.md"))
-
-  writeFileSync(
-    join(finalBaseDir, "docs/PHASES/roadmap.md"),
-    `# Fases del Proyecto
-
-## Fase 1 — Planificacin
-${detectedDomain ? `**Dominio:** ${detectedDomain}` : ""}
-**Objetivo:** Definir stack, estructura y configuracin en modo PLAN.
-`,
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ docs/PHASES/roadmap.md"))
-
-  writeFileSync(
-    join(finalBaseDir, "docs/LOGS/ACTIVIDAD/INDEX.md"),
-    "# Registro de Actividad\n\n| Fecha | Actividad | Notas |\n|---|---|---|\n",
-    "utf-8"
-  )
-  writeFileSync(
-    join(finalBaseDir, "docs/LOGS/ERRORES/INDEX.md"),
-    "# Registro de Errores\n\n| Fecha | Error | Solucin | Leccin |\n|---|---|---|---|\n",
-    "utf-8"
-  )
-  writeFileSync(
-    join(finalBaseDir, "docs/COMMITS/INDEX.md"),
-    "# ndice de Commits\n\n| Fecha | Versin | Descripcin |\n|---|---|---|\n",
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ docs/ (LOGS, COMMITS)"))
-
-  // ── Configuracin opencode con MCP dual ──
-  const opencodeConfig = {
-    $schema: "https://opencode.ai/config.json",
-    mcp: {
-      OPL: {
-        type: "local",
-        command: ["npx", "openprompt-lang", "mcp"],
-        enabled: true,
-      },
-      "OPL-Plan": {
-        type: "local",
-        command: ["npx", "openprompt-lang", "mcp-plan"],
-        enabled: true,
-      },
-    },
-    default_agent: "OPL-Plan",
-    instructions: ["AGENTS.md"],
-  }
-
-  const opencodeDir = join(finalBaseDir, ".opencode")
-  mkdirSync(opencodeDir, { recursive: true })
-  writeFileSync(
-    join(opencodeDir, "opencode.json"),
-    JSON.stringify(opencodeConfig, null, 2),
-    "utf-8"
-  )
-  console.log(chalk.green("  ✅ .opencode/opencode.json"))
-
-  // ── Work context ──
-  try {
-    const { init: initWorkContext } = await import("./work-context.js")
-    await initWorkContext(finalBaseDir)
-  } catch (e) {
-    console.log(chalk.yellow(`  ⚠️  work-context: ${e.message}`))
-  }
-
-  // ── Project context bsico ──
-  try {
-    const { generateProjectContext } = await import("./project-context.js")
-    await generateProjectContext(finalBaseDir, config, null, {
-      domain: detectedDomain,
-      features: {},
-    })
-  } catch (e) {
-    console.log(chalk.yellow(`  ⚠️  project-context: ${e.message}`))
-  }
-
-  // ── Instalar conocimiento ──
-  if (selectedBooks.length > 0) {
-    const __dirname = dirname(fileURLToPath(import.meta.url))
-    const knowledgeSourceDir = join(__dirname, "..", "templates", "knowledge-repo")
-    if (existsSync(knowledgeSourceDir)) {
-      console.log(chalk.cyan("\n⚙️  Instalando conocimiento filtrado..."))
-      const projectKnowledgeDir = join(finalBaseDir, "knowledge-repo")
-      const dirsToCopy = [
-        {
-          src: join(knowledgeSourceDir, "manifest.json"),
-          dest: join(projectKnowledgeDir, "manifest.json"),
-          recursive: false,
-        },
-        {
-          src: join(knowledgeSourceDir, "taxonomy"),
-          dest: join(projectKnowledgeDir, "taxonomy"),
-          recursive: true,
-        },
-        {
-          src: join(knowledgeSourceDir, "playbooks"),
-          dest: join(projectKnowledgeDir, "playbooks"),
-          recursive: true,
-        },
-        {
-          src: join(knowledgeSourceDir, "metadata"),
-          dest: join(projectKnowledgeDir, "metadata"),
-          recursive: true,
-        },
-        {
-          src: join(knowledgeSourceDir, "processed", "index"),
-          dest: join(projectKnowledgeDir, "processed", "index"),
-          recursive: true,
-        },
-      ]
-
-      for (const { src, dest, recursive } of dirsToCopy) {
-        if (existsSync(src)) {
-          mkdirSync(dirname(dest), { recursive: true })
-          cpSync(src, dest, { recursive })
-        }
-      }
-      console.log(chalk.green(`  ✅ Conocimiento instalado (${selectedBooks.length} libros)`))
-    }
-  }
-
-  // ── Establecer shared state a plan ──
-  setMode("plan", finalBaseDir)
-
-  // ── Post-init summary ──
-  console.log(chalk.cyan("\n✨ Resumen:\n"))
-  console.log(`  📁 ${finalName}/ creado`)
-  console.log(
-    `   Conocimiento: ${selectedBooks.length > 0 ? `${selectedBooks.length} libros filtrados` : "ninguno"}`
-  )
-  console.log(`   Modo: ${chalk.blue("PLAN")}`)
-  console.log("")
-
-  // ── Lanzar opencode en modo plan ──
-  if (usePlanMode) {
-    if (isOpencodeInstalled()) {
-      launchOpencodePlanWizard(finalBaseDir)
-    } else {
-      console.log(chalk.yellow("  ⚠️  opencode no est instalado."))
-      console.log(chalk.cyan("  📦 Instlalo: npm install -g opencode"))
-      console.log(chalk.cyan("  🚀 Luego ejecuta: opencode ."))
-      console.log(chalk.gray("     El Plan MCP te guiar para definir el stack y estructura."))
-    }
-  } else {
-    console.log(chalk.cyan("\n💡 Para configurar el proyecto ms tarde:"))
-    console.log(chalk.gray("   opl plan     — Abrir modo plan en opencode"))
-    console.log(chalk.gray("   opencode .   — Iniciar opencode con plan MCP"))
-  }
+  // ── Handoff a la IA ──
+  console.log(chalk.cyan("\n✨ OPL Init: Estructura base lista."))
+  console.log(chalk.yellow("OPL delega ahora la inicialización estratégica a tu Agente IA."))
+  console.log(chalk.white("Copia y pega el siguiente prompt en tu chat con la IA (ej. Cline, Cursor, OpenCode, etc.):\n"))
+  
+  console.log(chalk.bgGray.white(`
+"Asume el rol de Arquitecto Principal OPL. Acabo de ejecutar opl init para un proyecto NUEVO llamado '${finalName}'.
+
+Tu proceso obligatorio es:
+1. Ejecuta 'analyze_project' para inspeccionar el directorio base.
+2. Hazme preguntas para entender el contexto del proyecto (dominio, stack preferido, funcionalidades clave).
+3. Decide el stack óptimo con base en mis respuestas.
+4. Usa 'init_project' y 'scaffold_project' para configurar el proyecto.
+5. Genera los archivos canónicos: AGENTS.md, prompt-lang.json, .openprompt/FRAMEWORK.md.
+6. Confirma explícitamente que el proyecto quedó estabilizado e indícame el siguiente paso operativo."
+`))
 
   return finalBaseDir
 }

package/src/commands/init-existing.js

@@ -135,14 +135,27 @@ export async function initExisting(options = {}) {
     ? JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8")).name || "mi-proyecto"
     : "mi-proyecto"
 
-  if (rebuild) {
-    console.log(chalk.cyan(`\n🔧 Reconstruyendo integración OPL en: ${projectName}\n`))
-  } else {
-    console.log(
-      chalk.cyan(`\n🔧 Configurando openPrompt-Lang en proyecto existente: ${projectName}\n`)
-    )
+  if (!rebuild) {
+    console.log(chalk.cyan(`\n🔧 Inicializando OPL en proyecto existente: ${projectName}\n`))
+    console.log(chalk.cyan("✨ OPL Init: Entorno detectado."))
+    console.log(chalk.yellow("OPL delega ahora la inicialización estratégica a tu Agente IA."))
+    console.log(chalk.white("Copia y pega el siguiente prompt en tu chat con la IA (ej. Cline, Cursor, OpenCode, etc.):\n"))
+    
+    console.log(chalk.bgGray.white(`
+"Asume el rol de Arquitecto Principal OPL. Acabo de ejecutar opl init para un proyecto EXISTENTE llamado '${projectName}'.
+
+Tu proceso obligatorio es:
+1. Ejecuta 'analyze_project' para auditar el directorio, descubrir el stack actual y evaluar la deuda técnica.
+2. Hazme preguntas sobre lo que no puedas inferir del código existente.
+3. Genera la estructura que falte (docs/, work-context, AGENTS.md, prompt-lang.json, .openprompt/FRAMEWORK.md).
+4. Organiza un backlog inicial de refactorización con la deuda detectada.
+5. Confirma explícitamente que el proyecto quedó estabilizado e indícame el siguiente paso operativo."
+`))
+    return cwd
   }
 
+  console.log(chalk.cyan(`\\n🔧 Reconstruyendo integración OPL en: ${projectName}\\n`))
+
   const stack = enhancedDetectStack(cwd)
   const detected = Object.entries(stack)
     .filter(([, v]) => v)