@ingeniomaps/cauce 0.26.0 → 0.28.0

package/engine/cli/ops.js

@@ -19,9 +19,13 @@ const T = require('../teams/registry')
 const AG = require('../agents/catalog')
 const EV = require('../agents/evaluations')
 const { FLAGS, parse } = require('./args')
+const BOOT = require('./bootstrap')
 
 const PROJECT_ROOT = path.resolve(__dirname, '..', '..')
 
+// Dónde aterriza una instancia cuando nadie eligió: una carpeta propia junto al código.
+const DEFAULT_TARGET = 'ops'
+
 function fail(message, code = 1) {
   console.error(message)
   process.exit(code)
@@ -29,7 +33,8 @@ function fail(message, code = 1) {
 
 function usage() {
   console.log(`Uso:
-  ops init <destino> [--name <nombre>] [--mode embedded|sidecar] [--force]
+  ops init [destino] [--name <nombre>] [--mode embedded|sidecar] [--force]
+           [--runner claude|codex|gemini|antigravity] [--integration <proveedor>] [--install|--no-install]
   ops check <planning-dir> [--json]
   ops tree <planning-dir> [--no-color] [--json]
   ops context <planning-dir> [--json]
@@ -142,12 +147,8 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
     root,
   )
   const version = require(path.join(PROJECT_ROOT, 'package.json')).version
-  // El motor siempre llega como dependencia. La alternativa era vendorizarlo en `.ops/`, y no valía:
-  // Node hace falta igual en los dos casos —el motor, los guards y los workflows son JavaScript—, así
-  // que la copia sólo ahorraba este `package.json` de seis líneas a cambio de 5 MB en la historia de
-  // la empresa y de no tener cómo enterarse de que salió una versión nueva.
-  //
-  // El repo ops es un sidecar: declarar npm acá no convierte en Node al servicio de Go de al lado.
+  // El motor llega como dependencia para que el lockfile fije su versión. El repo ops es un sidecar:
+  // declarar npm acá no convierte en Node al servicio de Go de al lado.
   declareEngine(path.join(root, 'package.json'), version)
   let entregado = {}
   for (const relative of O.trackedPaths()) {
@@ -225,21 +226,110 @@ function evaluationBench(root, agent, caso, force) {
   return dir
 }
 
-function init(target, cli) {
-  if (!target) fail('Falta <destino>.', 2)
-  const mode = cli.value('--mode', 'embedded')
+// Dónde va la instancia cuando nadie eligió destino. Parada frecuente: el dev ya creó `acme-ops/` y
+// corre `init` adentro. Sin esto la instancia caía en `acme-ops/ops/` —una carpeta del toolkit dentro
+// de otra— y el proyecto quedaba llamándose «acme-ops». La carpeta que ya nombra al toolkit es la
+// instancia; no hay una segunda adentro.
+function implicitTarget(cwd) {
+  const base = path.basename(cwd)
+  return base === DEFAULT_TARGET || base.endsWith('-ops') ? '.' : DEFAULT_TARGET
+}
+
+// El nombre sale de la carpeta del proyecto, no de la que aloja la instancia: `ops/` y `acme-ops/`
+// nombran al toolkit, y quien lee `project` en la configuración espera leer «acme».
+function defaultName(root) {
+  const base = path.basename(root)
+  return base === DEFAULT_TARGET ? path.basename(path.dirname(root)) : base.replace(/-ops$/, '')
+}
+
+// El motor no se instala solo: `npm install` baja el paquete que `init` acaba de declarar, y sin él el
+// shim, los cargos, los equipos y los adaptadores no se resuelven. Correrlo desde acá es lo que hace que
+// una instalación sea un comando y no una lista. En Windows el ejecutable es `npm.cmd`.
+function npmInstall(root) {
+  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  const result = spawnSync(npm, ['install'], { cwd: root, stdio: 'inherit' })
+  if (result.error) {
+    console.error(`  no pude ejecutar npm (${result.error.code || result.error.message}).`)
+    return 1
+  }
+  return result.status === null ? 1 : result.status
+}
+
+// Un `cli` que no tiene banderas, para reusar un comando desde otro: el `--force` de `init` habla del
+// molde y no del wiring del runner, así que pasarle el suyo instalaría a la fuerza algo que nadie pidió.
+const SIN_BANDERAS = { has: () => false, value: (_flag, fallback = '') => fallback }
+
+// Lo que quedó pendiente, y sólo eso: cuando la instalación corrió, `check` ya se ejecutó y repetirlo
+// como sugerencia hace dudar de que haya pasado.
+function initSteps(enter, resultado) {
+  if (resultado.instalado) return []
+  const pasos = ['npm install']
+  if (resultado.runner !== BOOT.SIN_RUNNER) {
+    pasos.push(`node tools/ops.js automation install . ${resultado.runner}`)
+  }
+  pasos.push('node tools/ops.js check planning')
+  return pasos.map((paso, indice) => `  siguiente: ${indice === 0 ? enter : ''}${paso}`)
+}
+
+async function init(target, cli) {
+  // Sin destino la instancia va a `ops/` y en modo sidecar, en vez de volcarse donde esté parado el
+  // dev: un monorepo que recibe `planning/`, `teams/`, `organization/` y `AGENTS.md` en su primer
+  // nivel deja de distinguir qué es suyo y qué llegó del toolkit. Es el layout que `automation
+  // install` ya asume —el wiring del runner va al padre, donde se abre la herramienta—, así que lo
+  // único que faltaba era que fuera lo que pasa cuando no se elige nada.
+  const root = path.resolve(target || implicitTarget(process.cwd()))
+  const mode = cli.value('--mode', target ? 'embedded' : 'sidecar')
   if (!['embedded', 'sidecar'].includes(mode)) fail('--mode debe ser embedded o sidecar.', 2)
-  const name = cli.value('--name', path.basename(path.resolve(target)).replace(/-ops$/, ''))
-  const root = path.resolve(target)
+  const name = cli.value('--name', defaultName(root))
   const force = cli.has('--force')
-  const existing = fs.existsSync(root) ? fs.readdirSync(root) : []
+  // `.git` no cuenta como contenido: es lo único que hay en la carpeta que alguien acaba de crear y
+  // versionar para la instancia, y el toolkit no escribe nada adentro. Sin esta excepción el camino
+  // más natural —`mkdir acme-ops && git init && cauce init`— pedía `--force` para no pisar nada.
+  const existing = (fs.existsSync(root) ? fs.readdirSync(root) : []).filter((entry) => entry !== '.git')
   if (existing.length && !force) {
     fail(`El destino no está vacío: ${root}. Usa --force para agregar solo archivos faltantes.`)
   }
   scaffold(root, { name, mode, force })
-  console.log(`\n✓ ${name}: sistema ops creado en ${root}`)
-  console.log('  siguiente: npm install (el motor viene de la dependencia)')
-  console.log(`  siguiente: node ${path.join(root, 'tools', 'ops.js')} check ${path.join(root, 'planning')}`)
+  const relative = path.relative(process.cwd(), root)
+  const enter = relative && relative !== '.' ? `cd ${relative} && ` : ''
+  console.log(`\n✓ ${name}: sistema ops creado en ${root} (modo ${mode})`)
+
+  // Preguntar exige una terminal, e instalar baja un paquete y escribe `node_modules`: las dos cosas
+  // pasan cuando hay alguien mirando. Una corrida automatizada —CI, un contenedor, estas pruebas—
+  // recibe la instancia materializada y decide por bandera, sin descargas ni preguntas implícitas.
+  const interactivo = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  const opciones = {
+    runner: cli.value('--runner'),
+    integration: cli.value('--integration'),
+    runners: A.RUNNER_NAMES,
+    providers: providerNames(),
+    interactive: interactivo,
+    install: cli.has('--install') || (interactivo && !cli.has('--no-install')),
+  }
+  let resultado
+  try {
+    resultado = await BOOT.run(root, opciones, {
+      log: console.log,
+      npm: npmInstall,
+      installRunner: (runner) => automation('install', root, runner, SIN_BANDERAS),
+      enableProvider: (provider) => INTEGRATION.enable.run(root, provider),
+    })
+  } catch (error) { fail(error.message, 2) }
+
+  if (resultado.instalado) {
+    check(path.join(root, 'planning'), SIN_BANDERAS)
+    // Una instancia recién instalada funciona y no sabe nada de este proyecto: `organization/` es el
+    // molde y el roadmap está vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que
+    // es justo lo que un CLI determinista no puede hacer; el recorrido vive en el runner, así que lo
+    // único útil acá es decir cuál es y con qué se abre.
+    if (resultado.runner !== BOOT.SIN_RUNNER) {
+      console.log(`  siguiente: abrí ${resultado.runner} en este directorio y corré /onboard`)
+      console.log('    escanea el repositorio y deja escrito el contexto de la empresa y la primera épica')
+    }
+    console.log(`  listo: el ciclo empieza en ${path.join(relative || '.', 'planning', 'FLOW.md')}`)
+  }
+  for (const paso of initSteps(enter, resultado)) console.log(paso)
+  if (resultado.error) fail(`${resultado.error}: la instancia quedó creada pero todavía no funciona.`)
 }
 
 function check(dir, cli) {
@@ -1047,7 +1137,7 @@ async function run(cli) {
     fail(`${command}: bandera desconocida ${sobran.join(', ')}. ${acepta}`, 2)
   }
   const arg = cli.positional
-  if (command === 'init') init(arg[1], cli)
+  if (command === 'init') await init(arg[1], cli)
   else if (command === 'check') check(arg[1], cli)
   else if (command === 'tree') tree(arg[1], cli)
   else if (command === 'context') context(arg[1], cli)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",

package/template/planning/rules/system/conduct.md

@@ -67,3 +67,26 @@ establece ejecutando lo destructivo, queda en hipótesis; acá la abstención va
 
 No se infiere el default de una herramienta desde otra del mismo paquete, ni una regla de una jurisdicción
 desde otra. Una negativa correcta sostenida en un mecanismo falso queda tan comprometida como el mecanismo.
+
+## R15 — Lo que el contrato enumera no desaparece del entregable
+
+Una entrega puede estar incompleta; lo que no puede es parecer completa. Cuando el contrato enumera las
+dimensiones que una entrega cubre —los criterios de un scorecard, los ejes de un descubrimiento, los campos
+de un contrato de release, las secciones de un informe—, dejar una afuera sin que se vea produce algo que se
+lee entero y no lo está. Nadie va a pedir después lo que falta, porque nada indica que faltaba.
+
+El daño no está en la omisión sino en su forma. Una rúbrica cuyos pesos suman 100 %, una guía con todas sus
+preguntas, una plantilla con todos sus campos llenos: la estructura afirma completitud aunque ninguna frase
+lo diga, y quien decide sobre eso no tiene cómo saber que había una dimensión más.
+
+Una ausencia no deja rastro, así que no se detecta leyendo lo escrito: **antes de entregar se contrasta el
+entregable contra la enumeración del contrato**, dimensión por dimensión. Es mecánico y barato, y es lo
+único que la encuentra — revisar lo que está nunca muestra lo que no está.
+
+La dimensión que todavía no se puede cubrir no se borra: queda en el entregable con qué la activa, qué
+evidencia la cierra y quién la revisa. Declararla ausente alcanza sólo cuando cubrirla es imposible y no
+apenas prematuro, y esa declaración va donde iba la dimensión, no en una nota al pie: sirve para que la
+lea quien decide, no para dejar constancia de que se sabía.
+
+Es la contraparte de R13, y las dos terminan igual. Ahí lo que no se entrega es lo que sí se podía; acá lo
+que se entrega tapa lo que faltó. En los dos casos alguien decide con menos de lo que cree tener.