@ingeniomaps/cauce 0.53.0 → 0.53.1

package/engine/automation/config.js

@@ -0,0 +1,175 @@
+'use strict'
+
+// Cómo se fusiona y se retira lo nuestro dentro de un archivo del usuario: la configuración del runner
+// y el bloque enmarcado de un `AGENTS.md` compartido. Es una sola pregunta —qué entregamos y cómo se
+// saca sin llevarse lo ajeno— y cambia cuando cambia el formato de esos archivos, no cuando cambia un
+// comando.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const F = require('../core/files')
+const { supersededGuards } = require('./hooks')
+
+function mergeConfig(current, incoming) {
+  if (Array.isArray(incoming)) {
+    const values = [...(Array.isArray(current) ? current : []), ...incoming]
+    const seen = new Set()
+    return values.filter((value) => {
+      const key = JSON.stringify(value)
+      if (seen.has(key)) return false
+      seen.add(key)
+      return true
+    })
+  }
+  if (incoming && typeof incoming === 'object') {
+    const object = current && typeof current === 'object' && !Array.isArray(current)
+    const result = object ? { ...current } : {}
+    for (const [key, value] of Object.entries(incoming)) {
+      result[key] = mergeConfig(result[key], value)
+    }
+    return result
+  }
+  return incoming
+}
+
+// Una entrada de hook que puso Cauce se reconoce por el guard al que apunta: `automatization/hooks/`
+// es nuestro y ninguna empresa escribe ahí. Se saca del archivo del usuario antes de fusionar para que
+// el merge deje exactamente las de esta versión, ni una más.
+const DELIVERED = /automatization\/hooks\/guard-[a-z-]+\.sh/
+
+function withoutDeliveredHooks(config, live) {
+  const dropped = []
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      return node
+        .filter((item) => {
+          const command = item && typeof item === 'object' ? String(item.command || '') : ''
+          if (!DELIVERED.test(command)) return true
+          // Sólo se anuncia lo que ya no vuelve: una entrada que el merge repone quedó igual, y decir
+          // que se quitó y se puso la misma línea es ruido que esconde el caso que sí importa.
+          if (!live.has(command)) dropped.push(command)
+          return false
+        })
+        .map(walk)
+        .filter((item) => !(item && typeof item === 'object' && Array.isArray(item.hooks) && !item.hooks.length))
+    }
+    if (node && typeof node === 'object') {
+      return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, walk(value)]))
+    }
+    return node
+  }
+  return { config: walk(config), dropped }
+}
+
+// Por qué se fue cada entrada nuestra. Un guard suelto que ahora cubre un grupo no es lo mismo que una
+// ruta que dejó de existir: el primero se ejecutaba dos veces por herramienta —con `verify`, la suite
+// entera del proyecto dos veces por commit—, y el segundo no se ejecutaba nunca. Decirlo distinto es lo
+// único que le permite a alguien darse cuenta de cuál de los dos tenía.
+function reportRemoved(name, dropped, live, output) {
+  const wrappers = new Map()
+  const loose = []
+  for (const command of dropped) {
+    const hit = supersededGuards().find(
+      (entry) => command.endsWith(entry.file) && [...live].some((v) => v.endsWith(entry.wrapper)),
+    )
+    if (hit) wrappers.set(hit.wrapper, [...(wrappers.get(hit.wrapper) || []), hit.file])
+    else loose.push(command)
+  }
+  for (const [wrapper, files] of wrappers) {
+    output.log(`− ${name}: reemplazado ${[...new Set(files)].join(', ')} por ${wrapper}`)
+  }
+  for (const command of loose) output.log(`− ${name}: quitada una entrada obsoleta (${command})`)
+}
+
+function includesConfig(actual, expected) {
+  if (Array.isArray(expected)) {
+    return Array.isArray(actual) && expected.every((item) => {
+      return actual.some((value) => JSON.stringify(value) === JSON.stringify(item))
+    })
+  }
+  if (expected && typeof expected === 'object') {
+    return actual && typeof actual === 'object' && Object.entries(expected).every(([key, value]) => {
+      return includesConfig(actual[key], value)
+    })
+  }
+  return actual === expected
+}
+
+function hasHooks(config) {
+  if (config.hooks && Object.keys(config.hooks).length) return true
+  const events = [
+    'PreToolUse',
+    'PostToolUse',
+    'PreInvocation',
+    'PostInvocation',
+    'Stop',
+    'SessionEnd',
+  ]
+  return Object.values(config).some((entry) => {
+    return entry && typeof entry === 'object' && events.some((event) => event in entry)
+  })
+}
+
+// Quita de una estructura de configuración exactamente lo que este adaptador habría puesto, y nada más.
+// Es el inverso de `mergeConfig`: una entrada del usuario nunca coincide literalmente con la nuestra, así
+// que sobrevive; una que editó tampoco coincide, y por eso se conserva y se avisa en vez de borrarse.
+function unmergeConfig(current, incoming) {
+  if (Array.isArray(incoming)) {
+    if (!Array.isArray(current)) return current
+    const ours = new Set(incoming.map((value) => JSON.stringify(value)))
+    return current.filter((value) => !ours.has(JSON.stringify(value)))
+  }
+  if (incoming && typeof incoming === 'object') {
+    if (!current || typeof current !== 'object' || Array.isArray(current)) return current
+    const result = { ...current }
+    for (const [key, value] of Object.entries(incoming)) {
+      if (!(key in result)) continue
+      const clean = unmergeConfig(result[key], value)
+      // Una clave que queda vacía por habernos ido no es del usuario: la creamos nosotros al instalar.
+      const empty = clean === undefined
+        || (Array.isArray(clean) && !clean.length)
+        || (clean && typeof clean === 'object' && !Array.isArray(clean) && !Object.keys(clean).length)
+      if (empty) delete result[key]
+      else result[key] = clean
+    }
+    return result
+  }
+  return JSON.stringify(current) === JSON.stringify(incoming) ? undefined : current
+}
+
+const blockStart = (name) => `<!-- cauce:${name} inicio — lo reescribe "automation install", no editar -->`
+const blockEnd = (name) => `<!-- cauce:${name} fin -->`
+
+function isSharedFile(root, target) {
+  return path.resolve(target) === path.resolve(root, 'AGENTS.md')
+}
+
+function withoutBlock(text, name) {
+  const sourceRoot = text.indexOf(blockStart(name))
+  if (sourceRoot === -1) return text
+  const until = text.indexOf(blockEnd(name), sourceRoot)
+  if (until === -1) return text
+  return `${text.slice(0, sourceRoot)}${text.slice(until + blockEnd(name).length)}`.trimEnd()
+}
+
+function mergeInstruction(file, name, content) {
+  const actual = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+  const instructionBody = withoutBlock(actual, name).trimEnd()
+  const block = `${blockStart(name)}\n\n${content.trim()}\n\n${blockEnd(name)}\n`
+  F.atomicWrite(file, instructionBody ? `${instructionBody}\n\n${block}` : block)
+}
+
+function blockUpToDate(file, name, content) {
+  if (!fs.existsSync(file)) return false
+  const body = fs.readFileSync(file, 'utf8')
+  const sourceRoot = body.indexOf(blockStart(name))
+  const until = body.indexOf(blockEnd(name))
+  if (sourceRoot === -1 || until === -1) return false
+  return body.slice(sourceRoot + blockStart(name).length, until).trim() === content.trim()
+}
+
+module.exports = {
+  blockStart,
+  mergeConfig, withoutDeliveredHooks, reportRemoved, includesConfig, hasHooks,
+  unmergeConfig, isSharedFile, withoutBlock, mergeInstruction, blockUpToDate,
+}

package/engine/automation/hooks.js

@@ -0,0 +1,96 @@
+'use strict'
+
+// El wiring de guards: cuáles existen, cuáles corren agrupados y cuáles quedaron registrados de a uno
+// en una instancia vieja. Su reloj es el registro que los ejecuta —un guard nuevo entra por ahí—, no
+// el de los comandos que los instalan.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const H = require('../hooks/run')
+const O = require('../core/ownership')
+const M = require('../core/manifest')
+const { packagedAutomation } = require('./runners')
+
+// Los guards que el motor implementa, tomados del registro que los ejecuta. Sale de ahí y no de un
+// número escrito a mano: `automation check` anunciaba «11 guards» cuando hacía rato que eran doce, y
+// un conteo que envejece solo es peor que ninguno —dice que revisó menos de lo que revisó—.
+const GUARD_NAMES = Object.keys(H.guards)
+
+// Un `.sh` por grupo de más de un guard: es el que registra el runner para correrlos en un proceso.
+function groupWrappers() {
+  return Object.entries(H.hookGroups)
+    .filter(([, names]) => names.length > 1)
+    .map(([group]) => [group, `guard-${group.replace('pre-', '')}.sh`])
+}
+
+// Los scripts que la instancia debe tener, derivados del registro que los ejecuta en vez de copiados
+// a mano: la copia envejecía sin avisar, porque un guard nuevo del motor no entraba en la cuenta.
+//
+// Se comprueba en una sola dirección a propósito. Un `.sh` que no está acá no sobra: así es como una
+// empresa agrega el suyo —`guard-acme.sh` al lado de los nuestros—, que es lo que `upgrade` le dice
+// que haga y lo único que sobrevive a cada actualización.
+function expectedHooks() {
+  return [
+    'run-hook.sh',
+    ...groupWrappers().map(([, wrapper]) => wrapper),
+    ...GUARD_NAMES.map((name) => `guard-${name}.sh`),
+  ]
+}
+
+// Guards que hoy viven dentro de un grupo, con el wrapper que los reemplaza.
+function supersededGuards() {
+  const entries = []
+  for (const [group, wrapper] of groupWrappers()) {
+    for (const name of H.hookGroups[group]) entries.push({ file: `guard-${name}.sh`, wrapper })
+  }
+  return entries
+}
+
+// Wiring heredado: guards que ahora corren agrupados pero siguen registrados uno por uno.
+// Conviven sin romper nada, a costa de ejecutar el guard dos veces por herramienta.
+function legacyGuardWiring(config) {
+  const text = JSON.stringify(config)
+  const superseded = []
+  for (const [group, names] of Object.entries(H.hookGroups)) {
+    if (names.length < 2 || !text.includes(`guard-${group.replace('pre-', '')}.sh`)) continue
+    superseded.push(...names.filter((guard) => text.includes(`guard-${guard}.sh`)))
+  }
+  return superseded
+}
+
+// Guards de la instancia que ya no coinciden con los del paquete. Existir y ser ejecutable no
+// alcanza: un guard viejo no falla, deja de proteger sin decir nada. La instancia declaraba una
+// versión y nadie comprobaba que su runtime fuera realmente esa.
+function staleHooks(root) {
+  const packaged = packagedAutomation(root)
+  if (!packaged) return []
+  const shipped = path.join(packaged, 'hooks')
+  const mine = path.join(root, 'automatization', 'hooks')
+  const recorded = M.read(root)
+  const stale = []
+  let names = []
+  try { names = fs.readdirSync(shipped) } catch { return [] }
+  for (const file of names) {
+    const local = path.join(mine, file)
+    // Los que faltan ya los reporta el chequeo de arriba; acá sólo interesa el que quedó atrás.
+    if (!fs.existsSync(local)) continue
+    const current = M.digest(local)
+    if (current === M.digest(path.join(shipped, file))) continue
+    const delivered = recorded[`automatization/hooks/${file}`]
+    stale.push({ file, edited: Boolean(delivered) && delivered !== current })
+  }
+  return stale
+}
+
+function listHooks(output = console) {
+  const nameWidth = Math.max(...H.hookMetadata.map((hook) => hook.name.length))
+  const eventWidth = Math.max(...H.hookMetadata.map((hook) => hook.event.length))
+  for (const hook of H.hookMetadata) {
+    output.log(`${hook.name.padEnd(nameWidth)}  ${hook.event.padEnd(eventWidth)}  ${hook.purpose}`)
+  }
+}
+
+module.exports = {
+  GUARD_NAMES, groupWrappers, expectedHooks, supersededGuards,
+  legacyGuardWiring, staleHooks, listHooks,
+}