zugzbot-sdd 1.5.0

package/tools/sdd_compact_context.ts

@@ -0,0 +1,122 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+export default tool({
+  description: "Crea una consolidación técnica de alta densidad (compaction snapshot) de los artefactos de la fase actual para optimizar tokens y reiniciar la memoria del subagente.",
+  args: {
+    changeName: tool.schema.string().optional().describe("Nombre del cambio en kebab-case. Si se omite, se autodetectará del sdd-lock.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+
+    // 1. Detectar cambio
+    let changeName = args.changeName;
+    if (!changeName) {
+      const lockfilePath = path.join(projectRoot, ".openspec/sdd-lock.json");
+      const altLockPath = path.join(projectRoot, "openspec/sdd-lock.json");
+      let activeLockPath = fs.existsSync(lockfilePath) ? lockfilePath : (fs.existsSync(altLockPath) ? altLockPath : null);
+      if (activeLockPath) {
+        try {
+          const lockObj = JSON.parse(fs.readFileSync(activeLockPath, "utf-8"));
+          if (lockObj.change_name && lockObj.change_name !== "nuevo-cambio") {
+            changeName = lockObj.change_name;
+          }
+        } catch (e) {}
+      }
+    }
+
+    if (!changeName || changeName === "nuevo-cambio") {
+      return `[Compactor Blocked] Error: No se pudo resolver el nombre del cambio activo.`;
+    }
+
+    const changeDir = path.join(projectRoot, ".openspec/changes", changeName);
+    if (!fs.existsSync(changeDir)) {
+      return `[Compactor Blocked] Error: No se encuentra el directorio del cambio en ${path.relative(projectRoot, changeDir)}`;
+    }
+
+    // 2. Leer artefactos individuales
+    const proposalPath = path.join(changeDir, "proposal.md");
+    const specPath = path.join(changeDir, "specs/spec.md");
+    const archPath = path.join(changeDir, "orchestrator_architecture.md");
+    const tasksPath = path.join(changeDir, "orchestrator_tasks.md");
+
+    let proposalSummary = "No disponible";
+    let specsSummary = "No disponible";
+    let archSummary = "No disponible";
+    let tasksSummary = "No disponible";
+
+    if (fs.existsSync(proposalPath)) {
+      const content = fs.readFileSync(proposalPath, "utf-8");
+      const descMatch = content.match(/## Description[\s\S]*?(?=##|$)/i) || content.match(/#[\s\S]*?(?=##|$)/i);
+      proposalSummary = descMatch ? descMatch[0].trim() : content.substring(0, 500);
+    }
+
+    if (fs.existsSync(specPath)) {
+      const content = fs.readFileSync(specPath, "utf-8");
+      const scens: string[] = [];
+      const lines = content.split("\n");
+      lines.forEach(l => {
+        if (l.trim().startsWith("Scenario:") || l.trim().startsWith("Escenario:")) {
+          scens.push(l.trim());
+        }
+      });
+      specsSummary = scens.length > 0 ? `Escenarios validados:\n${scens.map(s => `- ${s}`).join("\n")}` : "Escenarios BDD no estructurados.";
+    }
+
+    if (fs.existsSync(archPath)) {
+      const content = fs.readFileSync(archPath, "utf-8");
+      const mermaid = content.match(/```mermaid[\s\S]*?```/i);
+      archSummary = mermaid ? `Esquema Arquitectónico:\n${mermaid[0]}` : "Sin diagramas Mermaid de arquitectura.";
+    }
+
+    if (fs.existsSync(tasksPath)) {
+      const content = fs.readFileSync(tasksPath, "utf-8");
+      const total = (content.match(/- \[[ xX]\]/g) || []).length;
+      const completed = (content.match(/- \[[xX]\]/g) || []).length;
+      tasksSummary = `Checklist de Tareas: ${completed}/${total} completadas.\n` + 
+        content.split("\n").filter(l => l.includes("- [ ]") || l.includes("- [x]")).slice(0, 10).join("\n") +
+        (total > 10 ? "\n... (y más)" : "");
+    }
+
+    // 3. Escribir el Snapshot consolidado
+    const snapshotPath = path.join(changeDir, "compaction_snapshot.md");
+    const nowStr = new Date().toISOString().split('T')[0];
+
+    const markdown = `# 🧠 Consolidado de Contexto de Alta Densidad (SDD Compaction)
+Fecha de consolidación: ${nowStr}
+Cambio Activo: \`${changeName}\`
+
+---
+
+## 📜 Propuesta y Objetivos
+${proposalSummary}
+
+---
+
+## 📐 Especificaciones y Escenarios
+${specsSummary}
+
+---
+
+## 🏛️ Estructura Arquitectónica
+${archSummary}
+
+---
+
+## 📋 Estado del Checklist
+${tasksSummary}
+
+---
+
+> [!TIP]
+> **Acción Recomendada para Limpiar Memoria de Contexto:**
+> Si eres un subagente y ves este archivo, tu memoria ha sido compactada con éxito.
+> Lee **únicamente** este archivo de consolidación para entender el estado actual y los contratos técnicos previos. Descarta la lectura repetitiva de chats históricos o archivos de logs antiguos.
+`;
+
+    fs.writeFileSync(snapshotPath, markdown, "utf-8");
+
+    return `[SDD Compactor] Consolidado de alta densidad generado con éxito en ${path.relative(projectRoot, snapshotPath)}.`;
+  }
+})

package/tools/sdd_generate_tree.ts

@@ -0,0 +1,64 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+
+function buildTreeString(dir: string, prefix = "", depth = 0, maxDepth = 2): string {
+  if (depth > maxDepth) return ""
+  let result = ""
+  let entries: string[] = []
+  try {
+    entries = fs.readdirSync(dir)
+  } catch (e) {
+    return result
+  }
+
+  const exclude = [
+    "node_modules",
+    ".git",
+    ".openspec",
+    ".opencode",
+    "dist",
+    ".next",
+    "build",
+    "coverage",
+    ".DS_Store"
+  ]
+
+  const filtered = entries.filter(e => !exclude.includes(e))
+
+  filtered.forEach((entry, idx) => {
+    const fullPath = path.join(dir, entry)
+    let isDir = false
+    try {
+      isDir = fs.statSync(fullPath).isDirectory()
+    } catch (e) {
+      return
+    }
+    const isLast = idx === filtered.length - 1
+    const connector = isLast ? "└── " : "├── "
+    result += prefix + connector + entry + (isDir ? "/" : "") + "\n"
+
+    if (isDir && depth < maxDepth) {
+      const newPrefix = prefix + (isLast ? "    " : "│   ")
+      result += buildTreeString(fullPath, newPrefix, depth + 1, maxDepth)
+    }
+  })
+
+  return result
+}
+
+export default tool({
+  description: "Escanea la estructura de directorios del proyecto de forma nativa e instantánea de hasta 3 niveles, filtrando carpetas pesadas como node_modules o .git, para retornar el árbol visual del proyecto sin costo de tokens.",
+  args: {
+    maxDepth: tool.schema.number().optional().default(2).describe("Nivel máximo de profundidad para el escaneo recursivo de directorios (por defecto 2, máx 3)")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const depth = Math.min(Math.max(args.maxDepth, 1), 3)
+
+    const tree = buildTreeString(projectRoot, "", 0, depth)
+    const projectName = path.basename(projectRoot)
+
+    return `Estructura de Carpetas del Proyecto: ${projectName}\n\n/\n${tree || "  (Vacío o error en lectura)"}`
+  }
+})

package/tools/sdd_install_autoskills.ts

@@ -0,0 +1,100 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+function readdirSafe(dir: string): string[] {
+  try { return fs.readdirSync(dir) } catch { return [] }
+}
+
+function rmrf(dir: string) {
+  fs.rmSync(dir, { recursive: true, force: true })
+}
+
+function moveSkill(srcDir: string, skillName: string, destBase: string): string {
+  const src = path.join(srcDir, skillName)
+  const dest = path.join(destBase, skillName)
+
+  if (fs.existsSync(dest)) rmrf(dest)
+  fs.mkdirSync(destBase, { recursive: true })
+  fs.renameSync(src, dest)
+
+  const skillFile = path.join(dest, "SKILL.md")
+  if (!fs.existsSync(skillFile)) {
+    const files = readdirSafe(dest).filter(f => f.endsWith(".md"))
+    if (files.length === 0) return `⚠️  ${skillName}: movido pero sin SKILL.md`
+    return `⚠️  ${skillName}: movido (SKILL.md no encontrado, .md alternativo: ${files.join(", ")})`
+  }
+  return `✓ ${skillName} → .opencode/skills/${skillName}/`
+}
+
+export default tool({
+  description: "Ejecuta npx autoskills y migra automáticamente los skills instalados en .agents/skills/ a .opencode/skills/. Integra detección post-instalación y reporte.",
+  args: {
+    dryRun: tool.schema.boolean().optional().default(false).describe("Si es true, solo muestra qué se movería sin ejecutar autoskills ni mover archivos")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory
+    const agentsSkillsDir = path.join(projectRoot, ".agents/skills")
+    const opencodeSkillsDir = path.join(projectRoot, ".opencode/skills")
+
+    const report: string[] = []
+    report.push("━━━ sdd_install_autoskills ━━━")
+
+    const beforeSkills = new Set(readdirSafe(agentsSkillsDir))
+
+    if (args.dryRun) {
+      report.push("[DRY-RUN] Saltando ejecución de npx autoskills")
+    } else {
+      try {
+        report.push("▶ Ejecutando npx -y autoskills --yes...")
+        const output = execSync("npx -y autoskills --yes 2>&1", {
+          cwd: projectRoot,
+          encoding: "utf-8",
+          timeout: 120000
+        })
+        const lines = output.split("\n").filter((l: string) => l.trim())
+        report.push(...lines.slice(0, 30).map((l: string) => `  ${l}`))
+        if (lines.length > 30) report.push(`  ... (${lines.length - 30} líneas más)`)
+      } catch (e: any) {
+        report.push(`❌ Error ejecutando autoskills: ${e.message || e}`)
+        return report.join("\n")
+      }
+    }
+
+    const afterSkills = readdirSafe(agentsSkillsDir)
+    const newSkills = afterSkills.filter(s => !beforeSkills.has(s))
+    const allSkills = afterSkills.filter(s => {
+      const skillPath = path.join(agentsSkillsDir, s)
+      try { return fs.statSync(skillPath).isDirectory() } catch { return false }
+    })
+
+    if (allSkills.length === 0) {
+      report.push("📭 No se encontraron skills en .agents/skills/ para migrar")
+      return report.join("\n")
+    }
+
+    if (args.dryRun) {
+      report.push("\n[DRY-RUN] Skills que se migrarían:")
+      for (const skill of allSkills) {
+        const tag = newSkills.includes(skill) ? "(nuevo)" : "(pre-existente)"
+        report.push(`  📦 ${skill} ${tag} → .opencode/skills/${skill}/`)
+      }
+    } else {
+      report.push("\n📦 Migrando skills a .opencode/skills/:")
+      for (const skill of allSkills) {
+        const result = moveSkill(agentsSkillsDir, skill, opencodeSkillsDir)
+        report.push(`  ${result}${newSkills.includes(skill) ? " (nuevo)" : " (movido)"}`)
+      }
+
+      const remaining = readdirSafe(agentsSkillsDir)
+      if (remaining.length === 0) {
+        try { fs.rmdirSync(agentsSkillsDir) } catch {}
+        report.push("🧹 .agents/skills/ eliminado (quedó vacío)")
+      }
+    }
+
+    report.push("━━━ fin ━━━")
+    return report.join("\n")
+  }
+})

package/tools/sdd_regression_detector.ts

@@ -0,0 +1,241 @@
+import { tool } from "@opencode-ai/plugin"
+import fs from "fs"
+import path from "path"
+import { execSync } from "child_process"
+
+function decodeGitPath(gitPath: string): string {
+  let cleaned = gitPath.replace(/^"|"$/g, "")
+  if (cleaned.includes("\\")) {
+    try {
+      const bytes: number[] = []
+      let i = 0
+      while (i < cleaned.length) {
+        if (cleaned[i] === "\\" && i + 3 < cleaned.length && /^[0-7]{3}$/.test(cleaned.substring(i + 1, i + 4))) {
+          const octalVal = cleaned.substring(i + 1, i + 4)
+          bytes.push(parseInt(octalVal, 8))
+          i += 4
+        } else {
+          if (cleaned[i] === "\\" && i + 1 < cleaned.length) {
+            const next = cleaned[i + 1]
+            if (next === "n") { bytes.push(10); i += 2 }
+            else if (next === "t") { bytes.push(9); i += 2 }
+            else if (next === "\\") { bytes.push(92); i += 2 }
+            else if (next === "\"") { bytes.push(34); i += 2 }
+            else { bytes.push(cleaned.charCodeAt(i)); i++ }
+          } else {
+            const code = cleaned.charCodeAt(i)
+            if (code < 128) {
+              bytes.push(code)
+            } else {
+              const buf = Buffer.from(cleaned[i], "utf-8")
+              for (let b = 0; b < buf.length; b++) {
+                bytes.push(buf[b])
+              }
+            }
+            i++
+          }
+        }
+      }
+      return Buffer.from(bytes).toString("utf-8")
+    } catch (e) {
+      return cleaned.replace(/\\([0-7]{3})/g, (match, octal) => {
+        return String.fromCharCode(parseInt(octal, 8))
+      })
+    }
+  }
+  return cleaned
+}
+
+function sanitizeGitPath(line: string): string {
+  const content = line.substring(3).trim()
+  if (content.includes(" -> ")) {
+    const parts = content.split(" -> ")
+    return decodeGitPath(parts[1])
+  }
+  return decodeGitPath(content)
+}
+
+// Analiza los errores de una salida de compilador y los mapea de forma limpia
+function parseCompilerErrors(errorOutput: string): Set<string> {
+  const errors = new Set<string>();
+  const lines = errorOutput.split("\n").filter(l => l.trim());
+  lines.forEach(line => {
+    // Captura líneas que parezcan errores de compilador (archivo con número de línea y mensaje)
+    const fileMatch = line.match(/^([a-zA-Z0-9_\-./]+)\(/) || line.match(/^([a-zA-Z0-9_\-./]+):\d+/) || line.match(/in\s+([a-zA-Z0-9_\-./]+\.py)/);
+    if (fileMatch) {
+      // Normalizar simplificando detalles variables de error
+      errors.add(line.trim());
+    }
+  });
+  return errors;
+}
+
+export default tool({
+  description: "Analiza el espacio de trabajo de forma diferencial usando compilación estática (ej: tsc) para detectar ÚNICAMENTE nuevos errores introducidos en esta fase de desarrollo, ignorando fallas de compilación o linter preexistentes.",
+  args: {
+    runCheck: tool.schema.boolean().optional().default(true).describe("Si es true, ejecuta la validación global de regresiones.")
+  },
+  async execute(args, context) {
+    const projectRoot = context.worktree || context.directory;
+    
+    if (!args.runCheck) {
+      return JSON.stringify({
+        status: "SKIPPED",
+        message: "Escaner de regresiones omitido."
+      });
+    }
+
+    // 1. Identificar archivos modificados de forma robusta
+    const modifiedFiles = new Set<string>();
+    const hasGit = fs.existsSync(path.join(projectRoot, ".git"));
+    if (hasGit) {
+      try {
+        const gitOutput = execSync("git status --porcelain", { cwd: projectRoot, encoding: "utf-8" });
+        gitOutput.split("\n").forEach(line => {
+          if (!line || line.length < 4) return;
+          const filePathRel = sanitizeGitPath(line);
+          modifiedFiles.add(filePathRel);
+        });
+      } catch (e) {}
+    }
+
+    // 2. Determinar stack de compilación estática
+    let command = "";
+    let languageLabel = "";
+
+    if (fs.existsSync(path.join(projectRoot, "tsconfig.json"))) {
+      command = "npx tsc --noEmit --pretty false";
+      languageLabel = "TypeScript (tsc)";
+    } else if (fs.existsSync(path.join(projectRoot, "platformio.ini"))) {
+      command = "pio run";
+      languageLabel = "PlatformIO (C++)";
+    } else if (fs.existsSync(path.join(projectRoot, "Cargo.toml"))) {
+      command = "cargo check";
+      languageLabel = "Rust (cargo check)";
+    } else if (fs.existsSync(path.join(projectRoot, "build.gradle"))) {
+      command = "./gradlew compileJava";
+      languageLabel = "Java (Gradle)";
+    } else if (fs.existsSync(path.join(projectRoot, "pom.xml"))) {
+      command = "mvn compile";
+      languageLabel = "Java (Maven)";
+    } else if (fs.existsSync(path.join(projectRoot, "package.json"))) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+        if (pkg.scripts?.build) {
+          command = "npm run build";
+          languageLabel = "JS/TS (npm run build)";
+        } else if (pkg.scripts?.lint) {
+          command = "npm run lint";
+          languageLabel = "JS/TS (npm run lint)";
+        }
+      } catch (e) {}
+    } else if (fs.existsSync(path.join(projectRoot, "requirements.txt")) || fs.existsSync(path.join(projectRoot, "pyproject.toml"))) {
+      command = "python3 -m py_compile $(find . -name '*.py' -not -path '*/.*' -not -path '*/node_modules/*')";
+      languageLabel = "Python (py_compile)";
+    }
+
+    if (!command) {
+      return JSON.stringify({
+        status: "APPROVED",
+        reason: "No se encontró un verificador estático compatible. Se asume conforme."
+      }, null, 2);
+    }
+
+    // 3. OBTENER LECTURA BASELINE (Errores preexistentes) vía Stash Temporal si hay cambios en Git
+    const preExistingErrors = new Set<string>();
+    let stashCreated = false;
+
+    if (hasGit && modifiedFiles.size > 0) {
+      try {
+        // Crear un stash temporal de los cambios en caliente
+        execSync("git stash push --keep-index --include-untracked -m 'sdd_temp_baseline'", { cwd: projectRoot, stdio: "ignore" });
+        stashCreated = true;
+
+        // Ejecutar compilador en la versión limpia para ver fallos preexistentes
+        try {
+          execSync(command, { cwd: projectRoot, stdio: "pipe" });
+        } catch (e: any) {
+          const rawBaselineOutput = e.stdout?.toString() || e.stderr?.toString() || "";
+          parseCompilerErrors(rawBaselineOutput).forEach(err => preExistingErrors.add(err));
+        }
+      } catch (e) {
+        // Fallback si falla el stasheo (ej. sin commits previos)
+      } finally {
+        // Restaurar cambios sí o sí
+        if (stashCreated) {
+          try {
+            execSync("git stash pop", { cwd: projectRoot, stdio: "ignore" });
+          } catch (e) {}
+        }
+      }
+    }
+
+    // 4. EJECUTAR COMPILACIÓN FINAL (Con cambios en caliente activos)
+    try {
+      execSync(command, { cwd: projectRoot, stdio: "pipe" });
+      
+      return JSON.stringify({
+        status: "APPROVED",
+        checker: languageLabel,
+        preExistingBypassedCount: preExistingErrors.size,
+        message: `✅ DETECTOR DE REGRESIONES: La validación estática de tipo '${languageLabel}' pasó de manera impecable. No se encontraron discrepancias de compilación en el espacio de trabajo.`
+      }, null, 2);
+    } catch (e: any) {
+      const errorOutput = e.stdout?.toString() || e.stderr?.toString() || e.message || "";
+      const currentErrors = parseCompilerErrors(errorOutput);
+
+      // Calcular errores nuevos de forma diferencial
+      const newErrors: string[] = [];
+      const localNewErrors: string[] = [];
+
+      currentErrors.forEach(err => {
+        // Si el error NO existía previamente
+        if (!preExistingErrors.has(err)) {
+          // Detectar si pertenece a un archivo que modificamos (error local) o a otro módulo (regresión)
+          const fileMatch = err.match(/^([a-zA-Z0-9_\-./]+)\(/) || err.match(/^([a-zA-Z0-9_\-./]+):\d+/) || err.match(/in\s+([a-zA-Z0-9_\-./]+\.py)/);
+          if (fileMatch) {
+            const filePath = fileMatch[1];
+            if (modifiedFiles.has(filePath)) {
+              localNewErrors.push(err);
+            } else if (!filePath.includes("node_modules") && !filePath.includes(".openspec") && !filePath.includes(".opencode")) {
+              newErrors.push(err);
+            }
+          } else {
+            // Error genérico sin archivo directo
+            newErrors.push(err);
+          }
+        }
+      });
+
+      // Si hay verdaderas regresiones (nuevos errores en módulos que NO modificamos)
+      if (newErrors.length > 0) {
+        return JSON.stringify({
+          status: "FAILED",
+          checker: languageLabel,
+          regressionCount: newErrors.length,
+          preExistingIgnoredCount: preExistingErrors.size,
+          regressions: newErrors.slice(0, 10),
+          message: `❌ DETECTOR DE REGRESIONES FALLIDO: Se han introducido errores de tipado o compilación en módulos externos que no modificaste directamente:\n\n${newErrors.slice(0, 5).map(r => `  - ⚠️ ${r}`).join("\n")}${newErrors.length > 5 ? `\n  ... y ${newErrors.length - 5} regresiones más.` : ""}\n\nNota: Se detectaron y omitieron de forma segura ${preExistingErrors.size} errores de compilación preexistentes para no bloquear tu desarrollo.`
+        }, null, 2);
+      }
+
+      // Si los nuevos errores son puramente en tus archivos modificados (error local de tu cambio)
+      if (localNewErrors.length > 0) {
+        return JSON.stringify({
+          status: "FAILED_LOCAL",
+          checker: languageLabel,
+          preExistingIgnoredCount: preExistingErrors.size,
+          message: `⚠️ VERIFICACIÓN DE CÓDIGO FALLIDA: Se detectaron errores de tipado/compilación locales en tus archivos modificados. Corrígelos antes de avanzar.\n\nSalida del compilador (Errores nuevos):\n${localNewErrors.slice(0, 10).map(e => `  - ${e}`).join("\n")}\n\nNota: Se omitieron de forma segura ${preExistingErrors.size} errores preexistentes.`
+        }, null, 2);
+      }
+
+      // Si el compilador falló pero todos los errores resultaron ser preexistentes, ¡Damos luz verde!
+      return JSON.stringify({
+        status: "APPROVED",
+        checker: languageLabel,
+        preExistingBypassedCount: preExistingErrors.size,
+        message: `✅ DETECTOR DE REGRESIONES APROBADO: El compilador detectó ${preExistingErrors.size} errores de compilación, pero todos son preexistentes en la base de código. Se aprueba la transición para no bloquear tu cambio.`
+      }, null, 2);
+    }
+  }
+})