refacil-sdd-ai 2.6.0 → 2.7.0

package/README.md

@@ -56,7 +56,7 @@ refacil-sdd-ai update        # Actualizar skills y hooks a la ultima version
 refacil-sdd-ai check-update  # Verifica si hay una version mas reciente en npm (usado por hook)
 refacil-sdd-ai check-review  # Verifica que el review se haya completado (usado por hook)
 refacil-sdd-ai compact-bash  # Hook de rewrite de comandos Bash bare (usado por hook, no invocar manual)
-refacil-sdd-ai compact stats     # Tabla de rewrites + tokens estimados + USD ahorrado
+refacil-sdd-ai compact stats     # Estadisticas completas (hook + ya-compacto) + tokens estimados + USD
 refacil-sdd-ai compact disable   # Desactiva el hook compact-bash sin desinstalarlo
 refacil-sdd-ai compact enable    # Reactiva el hook compact-bash
 refacil-sdd-ai compact clear-log # Limpia ~/.refacil-sdd-ai/compact.log
@@ -431,13 +431,13 @@ Fase 2A — linters, type checkers, build, sistema:
 **Subcomandos de control**:
 
 ```bash
-refacil-sdd-ai compact stats       # tabla de rewrites + tokens estimados + USD
+refacil-sdd-ai compact stats       # estadisticas completas (hook + ya-compacto) + tokens estimados + USD
 refacil-sdd-ai compact disable     # desactiva el hook sin desinstalar
 refacil-sdd-ai compact enable      # reactiva el hook
 refacil-sdd-ai compact clear-log   # limpia ~/.refacil-sdd-ai/compact.log
 ```
 
-**Telemetria**: cada rewrite genera una linea JSON en `~/.refacil-sdd-ai/compact.log` con timestamp, ruleId y estimacion de tokens ahorrados. El log se usa para el comando `compact stats` que agrega por regla y calcula costo estimado (a razon de $3/MTok input de Sonnet, conservador). La telemetria es local; nada se envia a la nube.
+**Telemetria**: cada evento genera una linea JSON en `~/.refacil-sdd-ai/compact.log` con timestamp, ruleId y estimacion de tokens. Hay dos tipos de evento: `hook_rewrite` (el hook reescribe) y `already_compact` (el comando ya llega compacto, asumido por skill/agente). `compact stats` muestra ambos por defecto y calcula costo estimado (a razon de $3/MTok input de Sonnet, conservador). La telemetria es local; nada se envia a la nube.
 
 **Flujo del hook**:
 

package/bin/cli.js

@@ -535,29 +535,65 @@ function handleCompactSubcommand(sub) {
 
 function showCompactStats() {
   const s = compactTelemetry.stats();
-  if (s.totalRewrites === 0) {
-    console.log('\n  No hay rewrites registrados todavia. El hook compact-bash aun no se ha disparado o esta deshabilitado.\n');
+  if (s.totalEvents === 0) {
+    console.log('\n  No hay eventos registrados todavia. Ejecuta comandos Bash para generar telemetria de compactacion.\n');
     return;
   }
 
-  const sorted = Object.entries(s.byRule).sort((a, b) => b[1].saved - a[1].saved);
+  const sortedRewrites = Object.entries(s.byRule)
+    .filter(([, data]) => data.rewriteCount > 0)
+    .sort((a, b) => b[1].rewriteSaved - a[1].rewriteSaved);
+  const sortedAlreadyCompact = Object.entries(s.byRule)
+    .filter(([, data]) => data.alreadyCompactCount > 0)
+    .sort((a, b) => b[1].alreadyCompactPotential - a[1].alreadyCompactPotential);
 
-  console.log(`\n  compact-bash stats (${s.totalRewrites} rewrites en total)\n`);
-  for (const [id, data] of sorted) {
-    const kTokens = (data.saved / 1000).toFixed(1);
+  console.log(`\n  compact-bash stats\n`);
+  console.log(`  Rewrites por hook: ${s.totalRewrites}`);
+  console.log(`  Comandos ya compactos detectados (skill/agente): ${s.totalAlreadyCompact}\n`);
+
+  if (sortedRewrites.length > 0) {
+    console.log('  Ahorro aplicado por hook (rewrite):');
+    for (const [id, data] of sortedRewrites) {
+      const kTokens = (data.rewriteSaved / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.rewriteCount).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens`,
+      );
+    }
+    const totalHookK = (s.totalSaved / 1000).toFixed(1);
+    const hookUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
+    console.log(
+      `    ${'Total hook'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalHookK.padStart(7)}k tokens (~$${hookUsd} USD)`,
+    );
+    console.log('');
+  }
+
+  if (sortedAlreadyCompact.length > 0) {
+    console.log('  Ahorro potencial ya capturado por skill/agente (sin rewrite):');
+    for (const [id, data] of sortedAlreadyCompact) {
+      const kTokens = (data.alreadyCompactPotential / 1000).toFixed(1);
+      console.log(
+        `    ${id.padEnd(18)} ${String(data.alreadyCompactCount).padStart(6)} eventos    ~${kTokens.padStart(7)}k tokens potenciales`,
+      );
+    }
+    const totalAgentK = (s.totalAlreadyCompactPotential / 1000).toFixed(1);
+    const agentUsd = ((s.totalAlreadyCompactPotential / 1_000_000) * 3).toFixed(2);
+    console.log(`    ${'-'.repeat(62)}`);
     console.log(
-      `    ${id.padEnd(18)} ${String(data.count).padStart(6)} rewrites   ~${kTokens.padStart(7)}k tokens estimados`,
+      `    ${'Total skill'.padEnd(18)} ${String(s.totalAlreadyCompact).padStart(6)} eventos    ~${totalAgentK.padStart(7)}k tokens (~$${agentUsd} USD)`,
     );
+    console.log('');
   }
-  const totalK = (s.totalSaved / 1000).toFixed(1);
-  const costUsd = ((s.totalSaved / 1_000_000) * 3).toFixed(2);
+
+  const totalK = (s.totalObservedPotential / 1000).toFixed(1);
+  const totalUsd = ((s.totalObservedPotential / 1_000_000) * 3).toFixed(2);
   console.log(`    ${'-'.repeat(62)}`);
   console.log(
-    `    ${'Total'.padEnd(18)} ${String(s.totalRewrites).padStart(6)} rewrites   ~${totalK.padStart(7)}k tokens (~$${costUsd} USD, Sonnet input)`,
+    `    ${'Total observado'.padEnd(18)} ${String(s.totalEvents).padStart(6)} eventos    ~${totalK.padStart(7)}k tokens (~$${totalUsd} USD, Sonnet input)`,
   );
   console.log(`\n  Log: ${compactTelemetry.LOG_PATH}`);
   if (compactTelemetry.isDisabled()) {
-    console.log('  Estado: DESHABILITADO (no se registran nuevos rewrites)');
+    console.log('  Estado: DESHABILITADO (no se registran nuevos eventos)');
   }
   console.log('');
 }
@@ -573,7 +609,7 @@ function help() {
     check-review  Verifica que el review se haya completado (usado por hook PreToolUse)
     compact-bash  Reescribe comandos Bash bare para reducir tokens (usado por hook PreToolUse)
     compact       Subcomandos del hook compact-bash:
-                    compact stats      - Estadisticas de rewrites y ahorro estimado
+                    compact stats      - Estadisticas completas (hook + ya-compacto) y ahorro estimado
                     compact disable    - Desactiva el rewrite temporalmente
                     compact enable     - Re-activa el rewrite
                     compact clear-log  - Borra el log historico

package/lib/compact/bash.js

@@ -1,5 +1,5 @@
 const fs = require('fs');
-const { findRule } = require('./rules');
+const { findRule, findAlreadyCompactRule } = require('./rules');
 const telemetry = require('./telemetry');
 
 function run() {
@@ -19,7 +19,13 @@ function run() {
   if (typeof origCommand !== 'string') return;
 
   const rule = findRule(origCommand);
-  if (!rule) return;
+  if (!rule) {
+    const compactRule = findAlreadyCompactRule(origCommand);
+    if (compactRule) {
+      telemetry.logAlreadyCompact(compactRule.id, compactRule.savedTokensEst);
+    }
+    return;
+  }
 
   let newCommand;
   try {

package/lib/compact/rules.js

@@ -13,6 +13,9 @@ const RULES = [
     id: 'git-log',
     match: (cmd) =>
       /^\s*git\s+log(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) =>
+      /^\s*git\s+log(\s|$)/.test(cmd) &&
+      (/--oneline\b/.test(cmd) || /(^|\s)-\d+\b/.test(cmd)),
     rewrite: (cmd) => cmd.replace(/^(\s*git\s+log)/, '$1 --oneline -20'),
     reason: 'git log → --oneline -20',
     savedTokensEst: 850,
@@ -21,6 +24,9 @@ const RULES = [
     id: 'git-status',
     match: (cmd) =>
       /^\s*git\s+status(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) =>
+      /^\s*git\s+status(\s|$)/.test(cmd) &&
+      (/\s-s(\s|$)/.test(cmd) || /--short\b/.test(cmd)),
     rewrite: (cmd) => cmd.replace(/^(\s*git\s+status)/, '$1 -s'),
     reason: 'git status → -s',
     savedTokensEst: 120,
@@ -28,6 +34,7 @@ const RULES = [
   {
     id: 'git-diff',
     match: (cmd) => /^\s*git\s+diff\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*git\s+diff(\s|$)/.test(cmd) && /--stat\b/.test(cmd),
     rewrite: (cmd) => cmd.replace(/^(\s*git\s+diff)\s*$/, '$1 --stat'),
     reason: 'git diff → --stat',
     savedTokensEst: 400,
@@ -36,6 +43,7 @@ const RULES = [
     id: 'git-show',
     match: (cmd) =>
       /^\s*git\s+show(\s|$)/.test(cmd) && !hasFlagAfterBase(cmd, 2),
+    compactMatch: (cmd) => /^\s*git\s+show(\s|$)/.test(cmd) && /--stat\b/.test(cmd),
     rewrite: (cmd) => cmd.replace(/^(\s*git\s+show)/, '$1 --stat'),
     reason: 'git show → --stat',
     savedTokensEst: 200,
@@ -49,6 +57,9 @@ const RULES = [
       if (/\s--since\b/.test(cmd)) return false;
       return true;
     },
+    compactMatch: (cmd) =>
+      /^\s*docker\s+logs(\s|$)/.test(cmd) &&
+      (/\s--tail\b/.test(cmd) || /\s-n\s+\d/.test(cmd) || /\s--since\b/.test(cmd)),
     rewrite: (cmd) => cmd.replace(/^(\s*docker\s+logs)/, '$1 --tail 100'),
     reason: 'docker logs → --tail 100',
     savedTokensEst: 1500,
@@ -56,6 +67,9 @@ const RULES = [
   {
     id: 'pkg-test',
     match: (cmd) => /^\s*(npm|yarn|pnpm)\s+(test|t)\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(npm|yarn|pnpm)\s+(test|t)\b/.test(cmd) &&
+      (hasPipeOrRedirect(cmd) || /--silent\b/.test(cmd) || /\b-q\b/.test(cmd)),
     rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
     reason: 'test bare → tail -80',
     savedTokensEst: 2400,
@@ -63,6 +77,9 @@ const RULES = [
   {
     id: 'jest-bare',
     match: (cmd) => /^\s*(npx\s+)?jest\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?jest(\s|$)/.test(cmd) &&
+      (/--silent\b/.test(cmd) || /--reporters=summary\b/.test(cmd)),
     rewrite: (cmd) =>
       cmd.replace(/^(\s*(?:npx\s+)?jest)\s*$/, '$1 --silent --reporters=summary'),
     reason: 'jest → silent summary',
@@ -71,6 +88,7 @@ const RULES = [
   {
     id: 'pytest-bare',
     match: (cmd) => /^\s*pytest\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*pytest(\s|$)/.test(cmd) && /(^|\s)-q(\s|$)/.test(cmd),
     rewrite: (cmd) => cmd.replace(/^(\s*pytest)\s*$/, '$1 -q'),
     reason: 'pytest → -q',
     savedTokensEst: 600,
@@ -79,6 +97,9 @@ const RULES = [
   {
     id: 'eslint',
     match: (cmd) => /^\s*eslint(\s+[^-]\S*)*\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*eslint(\s|$)/.test(cmd) &&
+      (/--format\s+compact\b/.test(cmd) || /--quiet\b/.test(cmd)),
     rewrite: (cmd) => {
       const tokens = cmd.trim().split(/\s+/);
       if (tokens.length === 1) {
@@ -93,6 +114,8 @@ const RULES = [
     id: 'biome-check',
     match: (cmd) =>
       /^\s*biome\s+check(\s|$)/.test(cmd) && !/--reporter\b/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*biome\s+check(\s|$)/.test(cmd) && /--reporter=summary\b/.test(cmd),
     rewrite: (cmd) =>
       cmd.replace(/^(\s*biome\s+check)/, '$1 --reporter=summary'),
     reason: 'biome check → --reporter=summary',
@@ -106,6 +129,8 @@ const RULES = [
       if (hasPipeOrRedirect(cmd)) return false;
       return true;
     },
+    compactMatch: (cmd) =>
+      /^\s*(npx\s+)?tsc(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
     rewrite: (cmd) => `${cmd.trim()} 2>&1 | head -80`,
     reason: 'tsc → head -80',
     savedTokensEst: 1200,
@@ -114,6 +139,8 @@ const RULES = [
     id: 'prettier-check',
     match: (cmd) =>
       /^\s*prettier\s+--check\b/.test(cmd) && !/--loglevel\b/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*prettier\s+--check\b/.test(cmd) && /--loglevel\b/.test(cmd),
     rewrite: (cmd) =>
       cmd.replace(/^(\s*prettier\s+--check)/, '$1 --loglevel warn'),
     reason: 'prettier --check → --loglevel warn',
@@ -122,6 +149,7 @@ const RULES = [
   {
     id: 'npm-audit',
     match: (cmd) => /^\s*npm\s+audit\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*npm\s+audit(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
     rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -10`,
     reason: 'npm audit → tail -10',
     savedTokensEst: 900,
@@ -129,6 +157,7 @@ const RULES = [
   {
     id: 'npm-ls',
     match: (cmd) => /^\s*npm\s+ls\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*npm\s+ls(\s|$)/.test(cmd) && /--depth=0\b/.test(cmd),
     rewrite: (cmd) => cmd.replace(/^(\s*npm\s+ls)/, '$1 --depth=0'),
     reason: 'npm ls → --depth=0',
     savedTokensEst: 700,
@@ -136,6 +165,8 @@ const RULES = [
   {
     id: 'cargo-bare',
     match: (cmd) => /^\s*cargo\s+(build|test|check)\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*cargo\s+(build|test|check)(\s|$)/.test(cmd) && /--quiet\b/.test(cmd),
     rewrite: (cmd) => `${cmd.trim()} --quiet`,
     reason: 'cargo → --quiet',
     savedTokensEst: 400,
@@ -149,6 +180,7 @@ const RULES = [
       if (hasPipeOrRedirect(cmd)) return false;
       return true;
     },
+    compactMatch: (cmd) => /^\s*go\s+test(\s|$)/.test(cmd) && hasPipeOrRedirect(cmd),
     rewrite: (cmd) => `${cmd.trim()} 2>&1 | tail -80`,
     reason: 'go test → tail -80',
     savedTokensEst: 1500,
@@ -156,6 +188,7 @@ const RULES = [
   {
     id: 'mvn-test',
     match: (cmd) => /^\s*mvn\s+test\s*$/.test(cmd),
+    compactMatch: (cmd) => /^\s*mvn\s+test(\s|$)/.test(cmd) && /(^|\s)-q(\s|$)/.test(cmd),
     rewrite: (cmd) => `${cmd.trim()} -q`,
     reason: 'mvn test → -q',
     savedTokensEst: 1800,
@@ -163,6 +196,9 @@ const RULES = [
   {
     id: 'gradle-test',
     match: (cmd) => /^\s*(\.\/gradlew|gradle)\s+test\s*$/.test(cmd),
+    compactMatch: (cmd) =>
+      /^\s*(\.\/gradlew|gradle)\s+test(\s|$)/.test(cmd) &&
+      /(^|\s)-q(\s|$)/.test(cmd),
     rewrite: (cmd) => `${cmd.trim()} -q`,
     reason: 'gradle test → -q',
     savedTokensEst: 1500,
@@ -187,4 +223,14 @@ function findRule(cmd) {
   return null;
 }
 
-module.exports = { RULES, findRule };
+function findAlreadyCompactRule(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  for (const rule of RULES) {
+    if (typeof rule.compactMatch === 'function' && rule.compactMatch(cmd)) {
+      return rule;
+    }
+  }
+  return null;
+}
+
+module.exports = { RULES, findRule, findAlreadyCompactRule };

package/lib/compact/telemetry.js

@@ -16,14 +16,16 @@ function isDisabled() {
   return fs.existsSync(DISABLED_PATH);
 }
 
-function logRewrite(ruleId, savedTokensEst) {
+function logEvent(eventType, ruleId, savedTokensEst, meta = {}) {
   try {
     ensureDir();
     const line =
       JSON.stringify({
         ts: new Date().toISOString(),
+        eventType: eventType || 'hook_rewrite',
         ruleId,
         savedTokensEst: savedTokensEst || 0,
+        ...meta,
       }) + '\n';
     fs.appendFileSync(LOG_PATH, line);
   } catch (_) {
@@ -31,6 +33,17 @@ function logRewrite(ruleId, savedTokensEst) {
   }
 }
 
+function logRewrite(ruleId, savedTokensEst) {
+  logEvent('hook_rewrite', ruleId, savedTokensEst);
+}
+
+function logAlreadyCompact(ruleId, savedTokensEst) {
+  // Assumption: command arrived compact due to skills/agent discipline.
+  logEvent('already_compact', ruleId, savedTokensEst, {
+    source: 'skill_assumed',
+  });
+}
+
 function readLog() {
   try {
     const content = fs.readFileSync(LOG_PATH, 'utf8');
@@ -54,13 +67,43 @@ function stats() {
   const entries = readLog();
   const byRule = {};
   let totalSaved = 0;
+  let totalAlreadyCompactPotential = 0;
+  let totalAlreadyCompact = 0;
+  let totalRewrites = 0;
+
   for (const e of entries) {
-    if (!byRule[e.ruleId]) byRule[e.ruleId] = { count: 0, saved: 0 };
-    byRule[e.ruleId].count++;
-    byRule[e.ruleId].saved += e.savedTokensEst || 0;
-    totalSaved += e.savedTokensEst || 0;
+    const eventType = e.eventType || 'hook_rewrite';
+    if (!byRule[e.ruleId]) {
+      byRule[e.ruleId] = {
+        rewriteCount: 0,
+        rewriteSaved: 0,
+        alreadyCompactCount: 0,
+        alreadyCompactPotential: 0,
+      };
+    }
+
+    if (eventType === 'already_compact') {
+      byRule[e.ruleId].alreadyCompactCount++;
+      byRule[e.ruleId].alreadyCompactPotential += e.savedTokensEst || 0;
+      totalAlreadyCompact++;
+      totalAlreadyCompactPotential += e.savedTokensEst || 0;
+    } else {
+      byRule[e.ruleId].rewriteCount++;
+      byRule[e.ruleId].rewriteSaved += e.savedTokensEst || 0;
+      totalRewrites++;
+      totalSaved += e.savedTokensEst || 0;
+    }
   }
-  return { byRule, totalSaved, totalRewrites: entries.length };
+
+  return {
+    byRule,
+    totalSaved,
+    totalRewrites,
+    totalAlreadyCompact,
+    totalAlreadyCompactPotential,
+    totalObservedPotential: totalSaved + totalAlreadyCompactPotential,
+    totalEvents: entries.length,
+  };
 }
 
 function disable() {
@@ -86,6 +129,7 @@ module.exports = {
   DISABLED_PATH,
   isDisabled,
   logRewrite,
+  logAlreadyCompact,
   stats,
   disable,
   enable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "refacil-sdd-ai",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "SDD-AI: Specification-Driven Development with AI — metodologia de desarrollo con IA usando OpenSpec, Claude Code y Cursor",
   "bin": {
     "refacil-sdd-ai": "./bin/cli.js"