openprompt-lang 1.2.4 → 1.2.7

package/src/commands/init-existing.js

@@ -135,18 +135,23 @@ export async function initExisting(options = {}) {
     ? JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8")).name || "mi-proyecto"
     : "mi-proyecto"
 
+  const interactive = options.interactive !== false && !!process.stdin.isTTY
   if (!rebuild) {
     console.log(chalk.cyan(`\n🔧 Inicializando OPL en proyecto existente: ${projectName}\n`))
-    
+
     // ── Verificar OpenCode ──
-    const interactive = options.interactive !== false && !!process.stdin.isTTY
     await checkAndInstallOpencode(interactive)
 
     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(`
+    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:
@@ -155,7 +160,8 @@ Tu proceso obligatorio es:
 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
   }
 
@@ -426,6 +432,27 @@ Tu proceso obligatorio es:
       console.log(chalk.yellow("  ⚠️  No se pudo ejecutar upgrade automáticamente."))
     }
 
+    if (interactive) {
+      const { updateKnowledge } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "updateKnowledge",
+          message:
+            "¿Deseas descargar/actualizar la biblioteca de conocimientos (Entorno Académico)?",
+          default: false,
+        },
+      ])
+
+      if (updateKnowledge) {
+        try {
+          const { initKnowledgeRepo } = await import("./opl-init-knowledge.js")
+          await initKnowledgeRepo(options)
+        } catch {
+          console.log(chalk.yellow("  ⚠️  No se pudo actualizar el conocimiento automáticamente."))
+        }
+      }
+    }
+
     console.log(chalk.cyan(`\n✅ Integración OLP reconstruida para: ${projectName}`))
     console.log(chalk.cyan(`   Versión OPL: ${config.oplVersion || "desconocida"}`))
     console.log(chalk.gray("   Archivos generados forzaron actualización."))

package/src/commands/init-helpers.js

@@ -288,7 +288,7 @@ export function setupOpencodeConfig(baseDir, _config) {
   const opencodeConfig = {
     $schema: "https://opencode.ai/config.json",
     mcp: {
-      openPrompt: { type: "local", command: ["npx", "openprompt-lang", "mcp"], enabled: true },
+      openPrompt: { type: "local", command: ["openprompt-lang", "mcp"], enabled: true },
     },
     skills: { paths: [".opencode/skills"] },
     default_agent: "openPrompt",
@@ -535,35 +535,41 @@ export async function selectFullStack(options) {
 }
 
 export async function checkAndInstallOpencode(interactive) {
-  if (!interactive) return;
+  if (!interactive) return
 
-  let isInstalled = false;
+  let isInstalled = false
   try {
-    execSync("opencode --version", { stdio: "ignore" });
-    isInstalled = true;
+    execSync("opencode --version", { stdio: "ignore" })
+    isInstalled = true
   } catch (e) {
-    isInstalled = false;
+    isInstalled = false
   }
 
   if (!isInstalled) {
-    console.log(chalk.yellow("\n⚠️  No se detectó 'opencode' instalado globalmente."));
-    console.log(chalk.gray("OpenCode es el agente CLI recomendado para aprovechar la integración MCP de OPL."));
+    console.log(chalk.yellow("\n⚠️  No se detectó 'opencode' instalado globalmente."))
+    console.log(
+      chalk.gray("OpenCode es el agente CLI recomendado para aprovechar la integración MCP de OPL.")
+    )
     const { install } = await inquirer.prompt([
       {
         type: "confirm",
         name: "install",
         message: "¿Deseas instalar opencode globalmente ahora? (npm install -g opencode)",
-        default: true
-      }
-    ]);
+        default: true,
+      },
+    ])
 
     if (install) {
-      console.log(chalk.cyan("⏳ Instalando opencode..."));
+      console.log(chalk.cyan("⏳ Instalando opencode..."))
       try {
-        execSync("npm install -g opencode", { stdio: "inherit" });
-        console.log(chalk.green("✅ opencode instalado exitosamente.\n"));
+        execSync("npm install -g opencode", { stdio: "inherit" })
+        console.log(chalk.green("✅ opencode instalado exitosamente.\n"))
       } catch (e) {
-        console.log(chalk.red("❌ Error instalando opencode. Puedes instalarlo manualmente con: npm install -g opencode\n"));
+        console.log(
+          chalk.red(
+            "❌ Error instalando opencode. Puedes instalarlo manualmente con: npm install -g opencode\n"
+          )
+        )
       }
     }
   }

package/src/commands/integrate.js

@@ -224,7 +224,7 @@ async function setupOpencode(cwd, config, langId, index) {
     mcp: {
       openPrompt: {
         type: "local",
-        command: ["npx", "openprompt-lang", "mcp"],
+        command: ["openprompt-lang", "mcp"],
         enabled: true,
       },
     },
@@ -349,8 +349,8 @@ async function setupVscode(cwd, config, langId) {
     servers: {
       "openPrompt-Lang": {
         type: "stdio",
-        command: "npx",
-        args: ["openprompt-lang", "mcp"],
+        command: "openprompt-lang",
+        args: ["mcp"],
       },
     },
   }
@@ -381,8 +381,8 @@ async function setupAntigravity(cwd, config, langId) {
     const globalMcp = {
       mcpServers: {
         "openPrompt-Lang": {
-          command: "npx",
-          args: ["openprompt-lang", "mcp"],
+          command: "openprompt-lang",
+          args: ["mcp"],
         },
       },
     }

package/src/commands/work-context.js

@@ -603,6 +603,15 @@ async function start(description) {
 
   writeJSON(SESSION_FILE, session)
   appendLog("session_start", description)
+
+  // Sincronizar con MCP shared state (workflow delivery → modo execute)
+  try {
+    const { syncWorkflowPhase } = await import("../mcp-shared-state.js")
+    syncWorkflowPhase("DELIVERY")
+  } catch {
+    /* silencioso */
+  }
+
   console.log(chalk.green(`\n✅ Sesión iniciada: ${session.session.id}\n`))
   console.log(`  ${chalk.bold("Tarea:")} ${description}`)
   console.log(`  ${chalk.bold("Rama:")}  ${branch}`)
@@ -824,6 +833,14 @@ async function close() {
   writeJSON(SESSION_FILE, session)
   appendLog("session_close", `Sesión cerrada: ${session.session.id}`)
 
+  // Sincronizar con MCP shared state (workflow close → modo plan de nuevo)
+  try {
+    const { syncWorkflowPhase } = await import("../mcp-shared-state.js")
+    syncWorkflowPhase("CLOSE_SESSION")
+  } catch {
+    /* silencioso */
+  }
+
   try {
     const { updateProjectContext } = await import("./project-context.js")
     await updateProjectContext(resolveBase())

package/src/commands/workflow/close/index.js

@@ -16,7 +16,7 @@ import {
 } from "../../../persistence/sqlite/queries.js"
 import { executeTransition, canTransition } from "../../../core/workflow/transitions.js"
 import { generateSessionDocs, generateIndexDoc } from "../../../docgen/session-docs.js"
-import { setPhase } from "../../../mcp-shared-state.js"
+import { setPhase, syncWorkflowPhase } from "../../../mcp-shared-state.js"
 import chalk from "chalk"
 
 /**
@@ -148,6 +148,7 @@ export async function closeWorkflow(options = {}) {
   setMetadata(db, "active_session", "")
   setMetadata(db, "active_ticket", "")
   setPhase("idle", process.cwd())
+  syncWorkflowPhase("CLOSE_SESSION")
 
   // ─── 3. Generar documentación viva ────────────────────────────────────
   const sessionFiles = generateSessionDocs({

package/src/commands/workflow/delivery/index.js

@@ -13,6 +13,7 @@ import {
   createTicket,
   createSession,
 } from "../../../persistence/sqlite/queries.js"
+import { syncWorkflowPhase } from "../../../mcp-shared-state.js"
 import { executeTransition, canTransition } from "../../../core/workflow/transitions.js"
 import { getPhase } from "../../../core/workflow/phases.js"
 import chalk from "chalk"
@@ -133,6 +134,9 @@ export async function delivery(options = {}) {
   setMetadata(db, "active_ticket", ticketId)
   setMetadata(db, "workflow_phase", "DELIVERY")
 
+  // Sincronizar con MCP shared state: DELIVERY → modo execute
+  syncWorkflowPhase("DELIVERY")
+
   conn.close()
 
   const phaseInfo = getPhase("DELIVERY")

package/src/commands/workflow/discovery/index.js

@@ -12,6 +12,7 @@ import {
   canTransition,
   getInitialContext,
 } from "../../../core/workflow/transitions.js"
+import { syncWorkflowPhase } from "../../../mcp-shared-state.js"
 import { runWizard, getWizardResponses } from "../../../wizard/orchestrator.js"
 import chalk from "chalk"
 
@@ -75,6 +76,9 @@ export async function discovery(options = {}) {
     setMetadata(db, "workflow_project_id", projectId)
   }
 
+  // Sincronizar con MCP shared state: DISCOVERY → modo plan
+  syncWorkflowPhase("DISCOVERY")
+
   conn.close()
 
   console.log(chalk.green(`\n✅ Discovery completado para: ${projectId}`))

package/src/commands/workflow/specification/index.js

@@ -8,6 +8,7 @@ import { ensureSchema } from "../../../persistence/sqlite/schema.js"
 import { runMigrations } from "../../../persistence/sqlite/migrations.js"
 import { getMetadata, setMetadata } from "../../../persistence/sqlite/queries.js"
 import { executeTransition, canTransition } from "../../../core/workflow/transitions.js"
+import { syncWorkflowPhase } from "../../../mcp-shared-state.js"
 import { getWizardResponses } from "../../../wizard/orchestrator.js"
 import { generateDocs } from "../../../docgen/generator.js"
 import {
@@ -103,6 +104,9 @@ export async function specification(options = {}) {
   executeTransition(ctx.currentPhase, "SPECIFICATION", ctx)
   setMetadata(db, "workflow_phase", "SPECIFICATION")
 
+  // Sincronizar con MCP shared state: SPECIFICATION → modo plan
+  syncWorkflowPhase("SPECIFICATION")
+
   conn.close()
 
   console.log(chalk.green(`\n✅ Specification completada para: ${projectId}`))

package/src/core/engine/sandbox.js

@@ -89,10 +89,12 @@ async function executeLocalFast(payload, cwd, startAt, startTime) {
     const timeout = constraints.timeoutMs || 30000
     let isTimeout = false
 
+    // shell: false — args ya se dividen manualmente (bin + args).
+    // Esto previene command injection si el comando contiene caracteres especiales.
     const child = spawn(bin, args, {
       cwd,
-      shell: true,
-      env: process.env, // Permitir entorno actual para local-fast
+      shell: false,
+      env: process.env,
     })
 
     const timeoutId = setTimeout(() => {
@@ -210,8 +212,10 @@ async function executeDockerEphemeral(payload, cwd, startAt, startTime) {
     let stderrRaw = ""
     let isTimeout = false
 
+    // shell: false — dockerArgs ya se parsean manualmente como array.
+    // Los comandos internos de docker se ejecutan via "sh -c '<cmd>'".
     const child = spawn("docker", dockerArgs, {
-      shell: true, // Necesario en Windows, pero útil para que interprete bien las comillas en los argumentos
+      shell: false,
     })
 
     const timeoutId = setTimeout(() => {

package/src/mcp-plan-server.js

@@ -57,7 +57,8 @@ const TOOLS = [
     name: "plan_create",
     description:
       "[PLAN MODE] Crear plan formal @workflow a partir de las respuestas del wizard. " +
-      "Genera un archivo .md en .opencode/work-context/PLANS/ con toda la configuración.",
+      "Genera un archivo .md en .opencode/work-context/PLANS/ con toda la configuración. " +
+      "NO cambia a EXECUTE automáticamente — usa plan_validate + plan_switch_mode después.",
     inputSchema: {
       type: "object",
       properties: {
@@ -453,9 +454,10 @@ async function handlePlanCreate(args) {
   })
 
   const planContent = loadPlanFile(planId)
-  const cwd = process.cwd()
-  approvePlan(planId, cwd)
-  setMode("execute", cwd)
+
+  // Nota: NO se cambia a EXECUTE automáticamente.
+  // El flujo correcto es: plan_create → plan_validate → plan_switch_mode
+  // Esto asegura que el plan esté completo antes de permitir ejecución.
 
   return {
     content: [
@@ -466,7 +468,12 @@ async function handlePlanCreate(args) {
             type: "plan_created",
             plan_id: planId,
             file_path: filePath,
-            message: `✅ Plan "${project_name}" creado y aprobado. Modo cambiado a EXECUTE.`,
+            mode: "plan",
+            message: `✅ Plan "${project_name}" creado. Usa plan_validate para verificar y plan_switch_mode para comenzar la ejecución.`,
+            next_steps: [
+              `plan_validate plan_id="${planId}"`,
+              `plan_switch_mode plan_id="${planId}"`,
+            ],
             plan_content: planContent,
           },
           null,

package/src/mcp-shared-state.js

@@ -212,4 +212,29 @@ export function isExecutionTool(toolName) {
   return EXECUTION_TOOLS.includes(toolName)
 }
 
+/**
+ * Sincroniza el modo MCP según la fase del workflow CLI.
+ * Conecta src/commands/workflow/ con el sistema MCP.
+ *
+ * Fases de planificación (DISCOVERY, SPECIFICATION) → mode "plan"
+ * Fases de ejecución (DELIVERY, CLOSE_SESSION) → mode "execute"
+ *
+ * @param {string} workflowPhase - Fase del workflow (DISCOVERY, SPECIFICATION, DELIVERY, CLOSE_SESSION)
+ * @param {string} [cwd] - Directorio del proyecto
+ */
+export function syncWorkflowPhase(workflowPhase, cwd) {
+  const planPhases = ["DISCOVERY", "SPECIFICATION", "BACKLOG_READY"]
+  const executePhases = ["DELIVERY", "CLOSE_SESSION"]
+
+  if (planPhases.includes(workflowPhase)) {
+    const state = getSharedState(cwd)
+    // Solo cambiar si no hay un plan aprobado en ejecución
+    if (!state.approved_at || state.mode !== "execute") {
+      setMode("plan", cwd)
+    }
+  } else if (executePhases.includes(workflowPhase)) {
+    setMode("execute", cwd)
+  }
+}
+
 export { PLAN_TOOLS, EXECUTION_TOOLS }

package/src/mcp-refactor/mcp-server.js

@@ -1,171 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync, existsSync, rmSync, writeFileSync, mkdirSync } from "fs"
-import { join, dirname } from "path"
-import { fileURLToPath } from "url"
-import { TOOLS } from "./tools.js"
-import { handleToolCall } from "./router.js"
-import { generateRichInstructions } from "../mcp-workflow.js"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-function getServerVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, "../..", "package.json"), "utf-8"))
-    return pkg.version || "0.9.0"
-  } catch {
-    return "0.9.0"
-  }
-}
-
-const SUPPORTED_PROTOCOL_VERSIONS = ["2024-11-05", "1.0", "1.0.0", "0.1.0"]
-const LATEST_PROTOCOL_VERSION = SUPPORTED_PROTOCOL_VERSIONS[0]
-
-const SERVER_INFO = {
-  name: "OPL",
-  version: getServerVersion(),
-}
-
-function sendMessage(msg) {
-  const data = JSON.stringify(msg)
-  process.stdout.write(`${data}\n`)
-}
-
-function sendError(id, code, message) {
-  sendMessage({ jsonrpc: "2.0", id, error: { code, message } })
-}
-
-function sendResult(id, result) {
-  sendMessage({ jsonrpc: "2.0", id, result })
-}
-
-export function startServer() {
-  // PID lock: evitar servidores duplicados
-  const PID_PATH = join(process.cwd(), ".opencode", "mcp.pid")
-  try {
-    if (existsSync(PID_PATH)) {
-      const oldPid = readFileSync(PID_PATH, "utf-8").trim()
-      try {
-        process.kill(parseInt(oldPid), 0)
-        console.error("[mcp] ⚠ Ya hay un servidor MCP activo (PID " + oldPid + "). Saliendo.")
-        process.exit(1)
-      } catch {
-        /* PID huérfano, continuar */
-      }
-    }
-    mkdirSync(dirname(PID_PATH), { recursive: true })
-    writeFileSync(PID_PATH, String(process.pid))
-  } catch {
-    /* fallback: continuar sin PID lock */
-  }
-
-  // Graceful shutdown: limpiar PID file y conexiones
-  function cleanupAndExit() {
-    try {
-      if (existsSync(PID_PATH)) rmSync(PID_PATH)
-    } catch {
-      /* ignore */
-    }
-    try {
-      import("../persistence/sqlite/connection.js").then((m) => m.close())
-    } catch {
-      /* ignore */
-    }
-    process.exit(0)
-  }
-  process.on("SIGTERM", cleanupAndExit)
-  process.on("SIGINT", cleanupAndExit)
-
-  let buffer = ""
-
-  process.stdin.setEncoding("utf-8")
-  process.stdin.on("data", async (chunk) => {
-    buffer += chunk
-    const lines = buffer.split("\n")
-    buffer = lines.pop() || ""
-
-    for (const line of lines) {
-      const trimmed = line.trim()
-      if (!trimmed) continue
-
-      let msg
-      try {
-        msg = JSON.parse(trimmed)
-      } catch {
-        continue
-      }
-
-      if (msg.jsonrpc !== "2.0") continue
-
-      const { id, method, params } = msg
-
-      const isNotification = id === undefined || id === null
-
-      switch (method) {
-        case "initialize": {
-          const clientVersion = params?.protocolVersion
-          const clientSupportsLatest =
-            clientVersion && SUPPORTED_PROTOCOL_VERSIONS.includes(clientVersion)
-          const negotiatedVersion = clientSupportsLatest ? clientVersion : LATEST_PROTOCOL_VERSION
-
-          // Generate rich dynamic instructions based on project context
-          const instructions = generateRichInstructions()
-
-          sendResult(id, {
-            protocolVersion: negotiatedVersion,
-            capabilities: {
-              tools: { listChanged: false },
-              logging: {},
-            },
-            serverInfo: SERVER_INFO,
-            instructions,
-          })
-          break
-        }
-
-        case "notifications/initialized": {
-          break
-        }
-
-        case "tools/list": {
-          sendResult(id, { tools: TOOLS })
-          break
-        }
-
-        case "tools/call": {
-          try {
-            const toolName = params?.name
-            const toolArgs = params?.arguments || {}
-            const result = await handleToolCall(toolName, toolArgs)
-            sendResult(id, result)
-          } catch (err) {
-            sendError(id, -32603, err.message)
-          }
-          break
-        }
-
-        case "ping": {
-          sendResult(id, {})
-          break
-        }
-
-        default: {
-          if (!isNotification) {
-            sendError(id, -32601, `Method not found: ${method}`)
-          }
-          break
-        }
-      }
-    }
-  })
-
-  process.stdin.on("end", () => {
-    cleanupAndExit()
-  })
-}
-
-// Start if main module
-if (import.meta.url === `file://${process.argv[1]}`) {
-  startServer()
-}