zugzbot 1.0.6 → 1.0.8

package/.opencode/commands/web.md

@@ -0,0 +1,17 @@
+---
+description: Inicia el centro de control web remoto de ZugzWeb
+---
+
+# 🤖 PANEL DE CONTROL WEB REMOTO (ZUGZWEB)
+
+Iniciando el servidor web local y abriendo el túnel seguro de Cloudflare en segundo plano para que puedas controlar y monitorear esta sesión de Opencode desde cualquier lugar del mundo (con internet)...
+
+!`node .utils/zugzweb/daemon.js > /dev/null 2>&1 &`
+
+### 🌍 ¿Cómo ingresar de forma remota?
+1. El Daemon se ha levantado en segundo plano en el puerto **4097**.
+2. Un túnel seguro de Cloudflare Quick Tunnel se está abriendo automáticamente.
+3. **Revisa tu terminal local**: Verás un banner impreso en color verde brillante con la URL pública remota de tipo:
+   `👉 https://your-session-id.trycloudflare.com 👈`
+4. Abre esa URL en tu teléfono móvil o laptop remota.
+5. ¡Podrás enviar prompts, ver el pensamiento del agente, monitorear los costos en tiempo real y habilitar alertas del navegador!

package/.opencode/plugins/sdd-bridge.ts

@@ -209,6 +209,88 @@ export const SddBridgePlugin: Plugin = async ({ project, client, $, directory, w
     }
   }
 
+  // Helper to synchronize models automatically from models.json
+  const syncModelsFromConfig = () => {
+    try {
+      const modelsPath = path.resolve(projectRoot, "models.json")
+      const altModelsPath = path.resolve(projectRoot, ".opencode/models.json")
+      let selectedModelsPath = ""
+
+      if (fs.existsSync(modelsPath)) {
+        selectedModelsPath = modelsPath
+      } else if (fs.existsSync(altModelsPath)) {
+        selectedModelsPath = altModelsPath
+      } else {
+        return // No config file, do nothing silently
+      }
+
+      const modelsContent = fs.readFileSync(selectedModelsPath, "utf8")
+      const modelsData = JSON.parse(modelsContent)
+      const globalModel = modelsData.global || "deepseek/deepseek-v4-flash"
+
+      // 1. Update opencode.json
+      const opencodeJsonPath = path.resolve(projectRoot, "opencode.json")
+      if (fs.existsSync(opencodeJsonPath)) {
+        const opencodeContent = fs.readFileSync(opencodeJsonPath, "utf8")
+        const opencodeData = JSON.parse(opencodeContent)
+        let updated = false
+
+        if (opencodeData.agent && typeof opencodeData.agent === "object") {
+          for (const agentName of Object.keys(opencodeData.agent)) {
+            const configModel = modelsData[agentName]
+            const targetModel = configModel && configModel.trim() !== "" ? configModel : globalModel
+
+            if (opencodeData.agent[agentName].model !== targetModel) {
+              opencodeData.agent[agentName].model = targetModel
+              updated = true
+            }
+          }
+        }
+
+        if (updated) {
+          fs.writeFileSync(opencodeJsonPath, JSON.stringify(opencodeData, null, 2), "utf8")
+          logPhase("MODEL_SYNC", "Sincronizados modelos en opencode.json desde models.json")
+        }
+      }
+
+      // 2. Update agent markdown files (.opencode/agents/*.md)
+      const agentsDir = path.resolve(projectRoot, ".opencode/agents")
+      if (fs.existsSync(agentsDir)) {
+        const files = fs.readdirSync(agentsDir)
+        for (const file of files) {
+          if (file.endsWith(".md")) {
+            const agentName = file.slice(0, -3)
+            const configModel = modelsData[agentName]
+            const targetModel = configModel && configModel.trim() !== "" ? configModel : globalModel
+            const filepath = path.join(agentsDir, file)
+            const content = fs.readFileSync(filepath, "utf8")
+
+            const frontmatterPattern = /^---$([\s\S]*?)^---$/m
+            const match = frontmatterPattern.exec(content)
+            if (match) {
+              const frontmatter = match[1]
+              if (frontmatter.includes("model:")) {
+                const modelLinePattern = /^model:\s*(.*?)$/m
+                const modelLineMatch = modelLinePattern.exec(frontmatter)
+                if (modelLineMatch && modelLineMatch[1].trim() !== targetModel) {
+                  const newFrontmatter = frontmatter.replace(modelLinePattern, `model: ${targetModel}`)
+                  const newContent = content.replace(frontmatter, newFrontmatter)
+                  fs.writeFileSync(filepath, newContent, "utf8")
+                  logPhase("MODEL_SYNC", `Sincronizado agente ${file} a modelo: ${targetModel}`)
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Best-effort: don't crash on model sync failures
+    }
+  }
+
+  // Run model sync from models.json automatically on plugin load
+  syncModelsFromConfig()
+
   // Ensure metrics file matches current contract on plugin load
   maybeResetMetrics()
 
@@ -233,7 +315,7 @@ export const SddBridgePlugin: Plugin = async ({ project, client, $, directory, w
       const currentState = readState()
 
       // Enforce: No code edits allowed unless we are in the implementation phase (F2_IMPLEMENTATION)
-      if (isWritingCode && !targetFilePath.includes("tests") && !targetFilePath.includes("specs") && !targetFilePath.includes(".opencode") && !targetFilePath.includes(".openspec") && !targetFilePath.includes("config.ts") && !targetFilePath.includes("config.js")) {
+      if (isWritingCode && !targetFilePath.includes("tests") && !targetFilePath.includes("specs") && !targetFilePath.includes(".opencode") && !targetFilePath.includes(".openspec") && !targetFilePath.includes(".utils") && !targetFilePath.includes("config.ts") && !targetFilePath.includes("config.js")) {
         if (currentState.phase !== "F2_IMPLEMENTATION") {
           throw new Error(
             `[SDD Contract Violation] No se permite escribir o editar código de la aplicación. Fase actual: '${currentState.phase}'. Debe transicionar a 'F2_IMPLEMENTATION' una vez que el contrato esté aprobado.`

package/.utils/docs_opencode/acp.md

@@ -0,0 +1,165 @@
+# Soporte ACP
+
+Utilice OpenCode en cualquier editor compatible con ACP.
+
+OpenCode admite el [Agent Client Protocol](https://agentclientprotocol.com) o (ACP), lo que le permite usarlo directamente en editores e IDE compatibles.
+
+> [!TIP]
+> Para obtener una lista de editores y herramientas compatibles con ACP, consulte el [informe de progreso de ACP](https://zed.dev/blog/acp-progress-report#available-now).
+
+ACP es un protocolo abierto que estandariza la comunicación entre editores de código y agentes de codificación de IA.
+
+---
+
+## [Configuración](#configuración)
+
+Para usar OpenCode a través de ACP, configure su editor para ejecutar el comando `opencode acp`.
+
+El comando inicia OpenCode como un subproceso compatible con ACP que se comunica con su editor a través de JSON-RPC a través de stdio.
+
+A continuación se muestran ejemplos de editores populares que admiten ACP.
+
+---
+
+### [Zed](#zed)
+
+Agregue a su configuración [Zed](https://zed.dev) (`~/.config/zed/settings.json`):
+
+**File**: ~/.config/zed/settings.json
+
+```json
+{
+  "agent_servers": {
+    "OpenCode": {
+      "command": "opencode",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+Para abrirlo, use la acción `agent: new thread` en la **Paleta de comandos**.
+
+También puedes vincular un atajo de teclado editando tu `keymap.json`:
+
+**File**: keymap.json
+
+```json
+[
+  {
+    "bindings": {
+      "cmd-alt-o": [
+        "agent::NewExternalAgentThread",
+        {
+          "agent": {
+            "custom": {
+              "name": "OpenCode",
+              "command": {
+                "command": "opencode",
+                "args": ["acp"]
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+]
+```
+
+---
+
+### [JetBrains IDEs](#jetbrains-ides)
+
+Agregue a su [JetBrains IDE](https://www.jetbrains.com/) acp.json de acuerdo con la [documentación](https://www.jetbrains.com/help/ai-assistant/acp.html):
+
+**File**: acp.json
+
+```json
+{
+  "agent_servers": {
+    "OpenCode": {
+      "command": "/absolute/path/bin/opencode",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+Para abrirlo, use el nuevo agente ‘OpenCode’ en el selector de agentes de AI Chat.
+
+---
+
+### [Avante.nvim](#avantenvim)
+
+Agregue a su configuración [Avante.nvim](https://github.com/yetone/avante.nvim):
+
+**File**:
+
+```lua
+{
+  acp_providers = {
+    ["opencode"] = {
+      command = "opencode",
+      args = { "acp" }
+    }
+  }
+}
+```
+
+Si necesita pasar variables de entorno:
+
+**File**:
+
+```lua
+{
+  acp_providers = {
+    ["opencode"] = {
+      command = "opencode",
+      args = { "acp" },
+      env = {
+        OPENCODE_API_KEY = os.getenv("OPENCODE_API_KEY")
+      }
+    }
+  }
+}
+```
+
+---
+
+### [CodeCompanion.nvim](#codecompanionnvim)
+
+Para usar OpenCode como agente ACP en [CodeCompanion.nvim](https://github.com/olimorris/codecompanion.nvim), agregue lo siguiente a su configuración de Neovim:
+
+**File**:
+
+```lua
+require("codecompanion").setup({
+  interactions = {
+    chat = {
+      adapter = {
+        name = "opencode",
+        model = "claude-sonnet-4",
+      },
+    },
+  },
+})
+```
+
+Esta configuración configura CodeCompanion para usar OpenCode como agente ACP para el chat.
+
+Si necesita pasar variables de entorno (como `OPENCODE_API_KEY`), consulte [Configuración de adaptadores: variables de entorno](https://codecompanion.olimorris.dev/getting-started#setting-an-api-key) en la documentación de CodeCompanion.nvim para obtener detalles completos.
+
+## [Soporte](#soporte)
+
+OpenCode funciona igual a través de ACP que en la terminal. Todas las funciones son compatibles:
+
+> [!NOTE]
+> Algunos comandos de barra integrados como `/undo` y `/redo` no son compatibles actualmente.
+
+- Herramientas integradas (operaciones de archivos, comandos de terminal, etc.)
+- Herramientas personalizadas y comandos de barra
+- Servidores MCP configurados en su configuración OpenCode
+- Reglas específicas del proyecto de `AGENTS.md`
+- Formateadores y linters personalizados
+- Sistema de agentes y permisos.