shilo-cli 0.7.0 → 0.8.0

package/src/commands/push.js

@@ -36,6 +36,11 @@ const PROPOSAL_MAX_BYTES = 4 * 1024 * 1024; // el server corta en 5 MB; margen
 const HEAD_BYTES = 8192;
 
 // Cuántos ejemplos se muestran por cada motivo de salteo.
+// Techo por campo del bloque `agent` y del prompt (Etapa 4, puntos 1 y 2). El
+// del prompt es el mismo que aplica el servidor: avisar acá ahorra el viaje.
+const AGENT_FIELD_MAX = 200;
+const PROMPT_MAX_BYTES = 64 * 1024;
+
 const SKIP_EXAMPLES = 5;
 // A partir de cuántos salteos en una misma carpeta de primer nivel sugerimos
 // ignorarla entera.
@@ -149,6 +154,61 @@ function preflight(dir) {
   return { uploads, skipped: skips, ignored, gitDirs, findings };
 }
 
+/**
+ * Aplica los selectores de `--only` sobre los archivos que dejó el preflight.
+ *
+ * Cada selector se normaliza con `sync.toRepoPath`, que ya blinda contra salir
+ * de la carpeta, y matchea por igualdad exacta o como prefijo de carpeta
+ * (`Documentacion/` alcanza todo lo de adentro).
+ *
+ * Un selector que no matchea nada es ERROR, no un push silencioso de todo:
+ * confundir "no subí nada de lo que pedí" con "subí el repo entero" es
+ * exactamente el fallo que arruinaría la confianza en el flag.
+ *
+ * Devuelve `{ uploads, leftOut }` o `{ error }`.
+ */
+function selectUploads(dir, allUploads, only) {
+  const selectors = (Array.isArray(only) ? only : only ? [only] : [])
+    .map((s) => String(s).trim())
+    .filter(Boolean);
+
+  if (selectors.length === 0) return { uploads: allUploads, leftOut: [] };
+
+  const normalized = [];
+  for (const raw of selectors) {
+    const repoPath = sync.toRepoPath(dir, raw);
+    if (!repoPath) return { error: `--only "${raw}" queda fuera de la carpeta del push.` };
+    normalized.push({ raw, repoPath });
+  }
+
+  const matched = new Set();
+  const uploads = [];
+  const leftOut = [];
+
+  for (const u of allUploads) {
+    const hit = normalized.find(
+      (s) => u.relPath === s.repoPath || u.relPath.startsWith(`${s.repoPath}/`)
+    );
+    if (hit) {
+      matched.add(hit.repoPath);
+      uploads.push(u);
+    } else {
+      leftOut.push(u);
+    }
+  }
+
+  const misses = normalized.filter((s) => !matched.has(s.repoPath));
+  if (misses.length > 0) {
+    return {
+      error:
+        `--only no encontró nada para: ${misses.map((s) => `"${s.raw}"`).join(', ')}. ` +
+        `Puede estar ignorado, salteado, o escrito distinto; nada se subió.`,
+    };
+  }
+
+  return { uploads, leftOut };
+}
+
 /**
  * Reporte agrupado de salteos. Un repo con un `venv/` adentro generaba miles de
  * líneas "saltado …" que tapaban todo lo demás; acá se resume por motivo, con
@@ -292,8 +352,26 @@ async function push(args) {
     return 1;
   }
 
+  // Procedencia (Etapa 4, punto 1). Sin --agent no se manda bloque alguno y el
+  // guardado queda como escrito por una persona, que es la verdad.
+  const agent = buildAgent(args);
+  if (agent && agent.error) {
+    ui.error(agent.error);
+    return 1;
+  }
+
+  const promptRead = readPrompt(args, agent);
+  if (promptRead.error) {
+    ui.error(promptRead.error);
+    return 1;
+  }
+  for (const w of promptRead.warnings) ui.warn(w);
+  const promptText = promptRead.prompt;
+
   // 3) PREFLIGHT: todo offline. Recién después de esto se toca la red.
-  const { uploads, skipped, ignored, gitDirs, findings } = preflight(dir);
+  //    `allUploads` es la carpeta entera; `--only` recorta DESPUÉS (ver 3b),
+  //    para que los ignores y el escáner de secretos corran igual siempre.
+  const { uploads: allUploads, skipped, ignored, gitDirs, findings } = preflight(dir);
 
   if (gitDirs.length > 0) {
     ui.warn(
@@ -320,12 +398,23 @@ async function push(args) {
     );
   }
 
-  if (uploads.length === 0) {
+  if (allUploads.length === 0) {
     ui.info('No hay archivos para subir.');
     ui.info(ui.c.dim(`(${ignored} ignorados, ${skipped.length} salteados)`));
     return 0;
   }
 
+  // 3b) `--only`: recorta QUÉ se sube, no qué se mira. El push nunca borra
+  //     archivos remotos (su plan es added/modified/unchanged/failed), así que
+  //     subir un subconjunto es seguro por construcción: no hay semántica nueva.
+  const selection = selectUploads(dir, allUploads, args.only);
+  if (selection.error) {
+    ui.error(selection.error);
+    return 1;
+  }
+  const uploads = selection.uploads;
+  const leftOut = selection.leftOut;
+
   // 4) Cliente + control de ritmo. `onThrottle` baja la concurrencia sola si el
   //    servidor empieza a responder 429, en vez de insistir hasta que corte.
   const limit = sync.resolveConcurrency(args);
@@ -533,8 +622,9 @@ async function push(args) {
       for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
       return 1;
     }
-    if (useIndex && !dryRun) saveIndex(dir, index, plan, uploads);
+    if (useIndex && !dryRun) saveIndex(dir, index, plan, allUploads);
     ui.success('Todo al día. Nada para subir.');
+    reportLeftOut(leftOut, remoteByPath);
     return 0;
   }
 
@@ -543,6 +633,7 @@ async function push(args) {
     for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}`);
     for (const f of plan.failed) ui.info(`  ${ui.c.red('!')} ${f.relPath} — ${f.reason}`);
     ui.info('');
+    reportLeftOut(leftOut, remoteByPath);
     ui.info(ui.c.dim('(--dry-run: no se subió nada)'));
     return plan.failed.length ? 1 : 0;
   }
@@ -714,7 +805,12 @@ async function push(args) {
       const title = buildMessage(message, changes.length, toSend.length, bi + 1, batches.length, card);
       let result;
       try {
-        result = await client.propose(projectId, { base, title, summary: '', changes }, await mgr.valid());
+        result = await client.propose(
+          projectId,
+          { base, title, summary: '', changes, agent, prompt: promptText, card },
+          await mgr.valid()
+        );
+        for (const w of result.warnings || []) ui.warn(w);
         config.persistCredsIfChanged(cfg, mgr.current);
       } catch (e) {
         // Una base que el servidor no conoce (proyecto recreado, historial
@@ -1131,7 +1227,7 @@ async function push(args) {
         );
         try {
           const creds = await mgr.valid();
-          await client.createCommit(projectId, msg, batchChanges, creds);
+          await client.createCommit(projectId, msg, batchChanges, creds, { card });
           committed += batchChanges.length;
           commitCount += 1;
           config.persistCredsIfChanged(cfg, mgr.current);
@@ -1175,7 +1271,7 @@ async function push(args) {
     for (const u of uploaded) {
       pushindex.record(index, u, pushedAt);
     }
-    saveIndex(dir, index, plan, uploads, pushedAt);
+    saveIndex(dir, index, plan, allUploads, pushedAt);
   }
 
   // 11) Anotar la sincronización y la base nueva. Sólo si TODO quedó en la
@@ -1189,6 +1285,7 @@ async function push(args) {
 
   // 12) Resumen final.
   ui.info('');
+  reportLeftOut(leftOut, remoteByPath);
   for (const o of open) reportOpen(o);
   if (stale > 0) {
     ui.warn(
@@ -1291,26 +1388,154 @@ async function loadContent(u) {
   return u.content;
 }
 
+/**
+ * Lo que `--only` dejó afuera. "Una pieza = una tarjeta" sólo funciona si la
+ * CLI te recuerda lo que quedó atrás.
+ *
+ * "Cambiado" se decide contra el ÁRBOL REMOTO —falta allá, o está con otro
+ * tamaño—, que es el mismo criterio de `shilo status` y no cuesta un request
+ * extra: el árbol ya se recorrió para planificar. El índice local no sirve acá:
+ * `pull` no lo escribe, así que en una carpeta que se bajó de nuevo queda viejo
+ * y daría por cambiado medio repo.
+ *
+ * Misma concesión que `status`: dos archivos del mismo tamaño se dan por
+ * iguales aunque difieran byte a byte.
+ */
+function reportLeftOut(leftOut, remoteByPath) {
+  if (!leftOut || leftOut.length === 0) return;
+
+  const changed = leftOut.filter((u) => {
+    const r = remoteByPath.get(u.relPath);
+    if (!r) return true; // nunca subido
+    return typeof r.size === 'number' && r.size !== u.size;
+  });
+  if (changed.length === 0) {
+    ui.info(
+      ui.c.dim(
+        `${leftOut.length} archivo(s) quedaron fuera de este push (--only); ninguno tiene cambios sin subir.`
+      )
+    );
+    return;
+  }
+
+  ui.warn(`${changed.length} archivo(s) con cambios locales quedaron fuera de este push (--only):`);
+  for (const u of changed.slice(0, SKIP_EXAMPLES)) ui.info(`      ${ui.c.dim(u.relPath)}`);
+  if (changed.length > SKIP_EXAMPLES) {
+    ui.info(ui.c.dim(`      … y ${changed.length - SKIP_EXAMPLES} más`));
+  }
+}
+
 /**
  * Registra en el índice los archivos que ya estaban idénticos (para no volver a
  * compararlos), saca los que ya no existen y lo escribe.
+ *
+ * `presentUploads` es lo que EXISTE en la carpeta, no lo que se subió en esta
+ * corrida: con `--only` son cosas distintas. Podar con la selección borraría del
+ * índice las entradas del resto del repo, y el push completo siguiente tendría
+ * que recompararlo todo — lento, no incorrecto, pero evitable. Las entradas
+ * nuevas se fusionan sobre el índice ya leído de disco, no lo reemplazan.
  */
-function saveIndex(dir, index, plan, uploads, pushedAt = Date.now()) {
+function saveIndex(dir, index, plan, presentUploads, pushedAt = Date.now()) {
   for (const u of plan.unchanged) {
     if (u.content != null) {
       pushindex.record(index, { ...u, hash: pushindex.hashContent(u.content) }, pushedAt);
     }
   }
-  pushindex.prune(index, new Set(uploads.map((u) => u.relPath)));
+  pushindex.prune(index, new Set(presentUploads.map((u) => u.relPath)));
   pushindex.write(dir, index);
 }
 
+/**
+ * El bloque `agent` que se declara al proponer, o null si nadie lo declaró.
+ *
+ * `--model` y `--session` sin `--agent` son un error y no un descuido que se
+ * pueda completar solo: decir qué modelo escribió algo sin decir qué
+ * herramienta lo corrió deja una procedencia que no se puede rastrear hasta
+ * ningún lado.
+ */
+function buildAgent(args) {
+  const name = typeof args.agent === 'string' && args.agent.trim() ? args.agent.trim() : null;
+  const model = typeof args.model === 'string' && args.model.trim() ? args.model.trim() : null;
+  const session = typeof args.session === 'string' && args.session.trim() ? args.session.trim() : null;
+
+  if (!name) {
+    if (model || session) {
+      return { error: 'Para declarar procedencia hace falta --agent <nombre>; --model y --session solos no alcanzan.' };
+    }
+    return null;
+  }
+
+  return {
+    name: name.slice(0, AGENT_FIELD_MAX),
+    ...(model ? { model: model.slice(0, AGENT_FIELD_MAX) } : {}),
+    ...(session ? { session_id: session.slice(0, AGENT_FIELD_MAX) } : {}),
+    tool: 'push',
+  };
+}
+
+/**
+ * El prompt que se sube, si quien llama lo pidió explícitamente.
+ *
+ * No se infiere del entorno ni se lee de ningún archivo por convención: un
+ * prompt puede llevar adentro cualquier cosa que alguien haya pegado en su
+ * terminal, y subir eso sin que nadie lo haya decidido es lo mismo que
+ * filtrarlo.
+ *
+ * Un prompt más largo que el techo se descarta con aviso, no se trunca: medio
+ * prompt es peor que ninguno porque parece completo.
+ */
+function readPrompt(args, agent) {
+  const file = typeof args['prompt-file'] === 'string' ? args['prompt-file'].trim() : '';
+  const inline = typeof args.prompt === 'string' ? args.prompt : '';
+
+  if (!file && !inline) return { prompt: null, warnings: [] };
+  if (file && inline) {
+    return { error: 'Elegí uno: --prompt o --prompt-file, no los dos.' };
+  }
+  if (!agent || agent.error) {
+    return { error: 'El prompt se guarda dentro de la procedencia del agente: agregá --agent <nombre>.' };
+  }
+
+  let text = inline;
+  if (file) {
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+      return { error: `No encontramos el archivo del prompt: ${resolved}` };
+    }
+    try {
+      text = fs.readFileSync(resolved, 'utf8');
+    } catch (e) {
+      return { error: `No se pudo leer el prompt: ${e.message}` };
+    }
+  }
+
+  if (!text.trim()) return { prompt: null, warnings: [] };
+
+  const bytes = Buffer.byteLength(text, 'utf8');
+  if (bytes > PROMPT_MAX_BYTES) {
+    return {
+      prompt: null,
+      warnings: [
+        `El prompt pesa ${Math.round(bytes / 1024)} KB y el techo es ` +
+          `${PROMPT_MAX_BYTES / 1024} KB: se guarda el cambio sin él.`,
+      ],
+    };
+  }
+
+  return { prompt: text, warnings: [] };
+}
+
 /**
  * Arma el mensaje del commit. Si vino `--card`, se agrega como trailer
  * `[card: <id>]` al final: queda visible en el historial y es fácil de grepear
  * para cruzar un cambio con la tarjeta que lo pidió (Metrónomo u otro tablero).
  * El backend corta en 500 caracteres, así que recortamos el mensaje del usuario
  * antes que el trailer.
+ *
+ * Desde la Etapa 4 la tarjeta viaja ADEMÁS aparte, en `provenance.card`, que es
+ * lo que se puede consultar (`GET /api/commits/<id>?card=…`). El trailer no se
+ * saca ni se va a sacar: es el formato de todo lo ya guardado, y la procedencia
+ * entra en el oid del commit, así que lo viejo no se puede completar.
  */
 function buildMessage(userMsg, batchCount, total, partNo, nBatches, card) {
   let base = userMsg || `shilo push: ${total} archivo(s)`;

package/src/commands/review.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const config = require('../config');
+const ui = require('../ui');
+const sync = require('../sync');
+const { resolveContext } = require('../context');
+
+/**
+ * shilo review [versión] [--aprobado | --reparos | --rechazado] [-m <nota>] [--json]
+ *
+ * Revisión humana (Etapa 4). Sin veredicto, lista quién revisó esa versión y
+ * qué dijo. Con uno, deja constancia. La versión es `actual` si no se dice
+ * otra cosa, o lo que imprime `shilo log` (alcanza un prefijo de 7 caracteres).
+ *
+ * El positional es una versión, no una carpeta: el contexto se resuelve siempre
+ * sobre el directorio actual, igual que en `log`.
+ */
+const FLAGS = { aprobado: 'aprobado', reparos: 'con_reparos', rechazado: 'rechazado' };
+
+const ETIQUETAS = {
+  aprobado: 'aprobado',
+  con_reparos: 'con reparos',
+  rechazado: 'rechazado',
+};
+
+async function review(args) {
+  const version = typeof args._[0] === 'string' && args._[0].trim() ? args._[0].trim() : 'actual';
+  const elegidos = Object.keys(FLAGS).filter((f) => args[f]);
+  if (elegidos.length > 1) {
+    ui.error('Elegí un solo veredicto: --aprobado, --reparos o --rechazado.');
+    return 1;
+  }
+  const verdict = elegidos.length ? FLAGS[elegidos[0]] : null;
+  const note = typeof args.message === 'string' ? args.message.trim() : '';
+
+  if (!verdict && note) {
+    ui.error('La nota va con un veredicto: --aprobado, --reparos o --rechazado.');
+    return 1;
+  }
+  // La 017 lo exige igual; avisarlo acá ahorra un viaje y dice por qué.
+  if (verdict && verdict !== 'aprobado' && !note) {
+    ui.error('Un reparo o un rechazo necesita una nota que diga qué falta: -m "<nota>".');
+    return 1;
+  }
+
+  const ctx = resolveContext({ ...args, _: [] });
+  if (!ctx.ok) return ctx.code;
+  const { projectId, cfg, client, mgr } = ctx;
+
+  let result;
+  try {
+    const creds = await mgr.valid();
+    result = verdict
+      ? await client.review(projectId, { version, verdict, note }, creds)
+      : await client.listReviews(projectId, version, creds);
+  } catch (e) {
+    ui.error(e.message);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify({ projectId, version: result.version, reviews: result.reviews }, null, 2));
+    return 0;
+  }
+
+  const corto = result.version ? String(result.version).slice(0, 8) : version;
+  if (verdict) ui.success(`Revisión registrada: ${ETIQUETAS[verdict]} (${corto}).`);
+
+  ui.info(`Revisiones de ${ui.c.yellow(corto)}`);
+  ui.info('');
+  if (result.reviews.length === 0) {
+    ui.info('Nadie la revisó todavía.');
+    ui.info(ui.c.dim('Para revisarla: shilo review ' + (version === 'actual' ? '' : version + ' ') + '--aprobado'));
+    return 0;
+  }
+  for (const r of result.reviews) {
+    ui.info(`${pintar(r.verdict)}  ${ui.c.bold(sync.describeAuthor(r.reviewer))}  ${ui.c.dim(sync.formatDate(r.reviewed_at))}`);
+    if (r.note) ui.info(`    ${r.note}`);
+  }
+  return 0;
+}
+
+function pintar(verdict) {
+  const texto = ETIQUETAS[verdict] || verdict;
+  if (verdict === 'aprobado') return ui.c.green(texto);
+  if (verdict === 'rechazado') return ui.c.red(texto);
+  return ui.c.yellow(texto);
+}
+
+/** Una marca corta para `shilo log`: la revisión más reciente manda. */
+function marcaDeRevision(reviews) {
+  if (!Array.isArray(reviews) || reviews.length === 0) return '';
+  const ultima = reviews[0];
+  const extra = reviews.length > 1 ? ` +${reviews.length - 1}` : '';
+  return `${pintar(ultima.verdict)} por ${sync.describeAuthor(ultima.reviewer)}${extra}`;
+}
+
+module.exports = review;
+module.exports.marcaDeRevision = marcaDeRevision;

package/src/commands/status.js

@@ -57,10 +57,24 @@ async function status(args) {
 
   // 3) "Detrás del remoto" = lo que otro subió y yo no tengo igual: archivos
   //    que faltan localmente, o que difieren y cambiaron después de mi lastSync.
+  //
+  //    Lo que está ignorado localmente NO cuenta como "atrás": `walkLocal` no
+  //    lo ve, así que quedaría en `onlyRemote` para siempre y el exit 2 —que
+  //    significa "pull antes de trabajar"— se volvería ruido permanente. Se
+  //    informa aparte: que alguien haya subido tu `settings.local.json` importa,
+  //    pero no es trabajo que te falte bajar.
+  const isIgnoredPath = sync.makePathMatcher(dir);
+
   const behind = [];
+  const ignoredRemote = [];
   for (const item of cmp.onlyRemote) {
+    if (isIgnoredPath(item.repoPath)) {
+      ignoredRemote.push({ ...item, kind: 'ignorado local' });
+      continue;
+    }
     behind.push({ ...item, kind: 'falta local' });
   }
+  ignoredRemote.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
   for (const item of cmp.differing) {
     if (sync.changedSinceSync(item.remote, lastSync) !== false) {
       behind.push({ ...item, kind: 'difiere' });
@@ -97,6 +111,9 @@ async function status(args) {
           localFiles: local.files.length,
           behind: behind.map((i) => ({ path: i.repoPath, kind: i.kind, lastCommit: decorate(i) })),
           ahead: ahead.map((i) => ({ path: i.repoPath, kind: i.kind })),
+          // Campo aparte a propósito: si fueran parte de `behind`, un script
+          // volvería a leer "estás desactualizado" por algo que nunca vas a bajar.
+          ignoredRemote: ignoredRemote.map((i) => ({ path: i.repoPath })),
           unchanged: cmp.same.length,
           listErrors: tree.errors,
         },
@@ -125,8 +142,25 @@ async function status(args) {
   }
   ui.info('');
 
+  /** Los ignorados que existen en el remoto: una línea, o la lista con --show-ignored. */
+  const reportIgnored = () => {
+    if (ignoredRemote.length === 0) return;
+    ui.info(
+      ui.c.dim(
+        `${ignoredRemote.length} archivo(s) existen en el remoto pero están ignorados localmente` +
+          (args['show-ignored'] ? ':' : ' (--show-ignored para verlos).')
+      )
+    );
+    if (args['show-ignored']) {
+      for (const item of ignoredRemote) ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(item.repoPath)}`);
+    }
+    ui.info('');
+  };
+
   if (behind.length === 0 && ahead.length === 0) {
     ui.success(`Al día: ${cmp.same.length} archivo(s) coinciden con el remoto.`);
+    ui.info('');
+    reportIgnored();
     return 0;
   }
 
@@ -156,6 +190,8 @@ async function status(args) {
     ui.info('');
   }
 
+  reportIgnored();
+
   ui.info(
     ui.c.dim(
       `  ${cmp.same.length} sin cambios (por tamaño)   ` +