refacil-sdd-ai 4.2.4 → 4.4.0

package/lib/commands/sdd.js

@@ -0,0 +1,447 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  const { root } = path.parse(dir);
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, 'refacil-sdd')) || fs.existsSync(path.join(dir, '.git'))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+
+const projectRoot = findProjectRoot();
+
+// --- Helpers ---
+
+function parseArgs(argv) {
+  const args = { _positional: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token) continue;
+    if (!token.startsWith('--')) {
+      args._positional.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith('--')) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i++;
+    }
+  }
+  return args;
+}
+
+function validateChangeName(name) {
+  if (!name || name.trim() === '') {
+    return { valid: false, reason: 'El nombre del cambio no puede estar vacío.' };
+  }
+  if (/[A-Z]/.test(name[0])) {
+    return { valid: false, reason: 'El nombre no puede empezar con mayúscula. Usa solo minúsculas, números y guiones.' };
+  }
+  if (/^[0-9]/.test(name)) {
+    return { valid: false, reason: 'El nombre no puede empezar con un número. Debe comenzar con una letra minúscula.' };
+  }
+  if (name.includes('_')) {
+    return { valid: false, reason: 'El nombre no puede contener guiones bajos (_). Usa guiones medios (-).' };
+  }
+  if (name.includes('/') || name.includes('.')) {
+    return { valid: false, reason: 'El nombre no puede contener / ni . (puntos). Usa solo letras, números y guiones medios.' };
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    return { valid: false, reason: 'El nombre solo puede contener letras minúsculas, números y guiones medios, y debe comenzar con una letra minúscula.' };
+  }
+  return { valid: true };
+}
+
+function autoMigrateOpenspec(root) {
+  const oldDir = path.join(root, 'openspec');
+  const newDir = path.join(root, 'refacil-sdd');
+  const oldExists = fs.existsSync(oldDir);
+  const newExists = fs.existsSync(newDir);
+  if (oldExists && !newExists) {
+    try {
+      fs.renameSync(oldDir, newDir);
+    } catch (err) {
+      throw new Error(`No se pudo migrar openspec/ a refacil-sdd/: ${err.message}`);
+    }
+  }
+  // Si ambos existen o ninguno existe → no hacer nada
+}
+
+// --- Subcomandos ---
+
+function cmdValidateName(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+  const result = validateChangeName(name);
+  if (result.valid) {
+    process.exit(0);
+  } else {
+    console.log(result.reason);
+    process.exit(1);
+  }
+}
+
+function cmdNewChange(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  const validation = validateChangeName(name);
+  if (!validation.valid) {
+    console.error(validation.reason);
+    process.exit(1);
+  }
+
+  autoMigrateOpenspec(projectRoot);
+
+  const changeDir = path.join(projectRoot, 'refacil-sdd', 'changes', name);
+  if (fs.existsSync(changeDir)) {
+    console.error(`Ya existe un cambio con el nombre '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(changeDir, { recursive: true });
+
+  const artifacts = ['proposal', 'design', 'tasks', 'specs'];
+  for (const artifact of artifacts) {
+    fs.writeFileSync(path.join(changeDir, `${artifact}.md`), `# ${artifact}: ${name}\n`);
+  }
+
+  console.log(`Cambio '${name}' creado en refacil-sdd/changes/${name}/`);
+}
+
+function cmdArchive(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  const validation = validateChangeName(name);
+  if (!validation.valid) {
+    console.error(validation.reason);
+    process.exit(1);
+  }
+
+  autoMigrateOpenspec(projectRoot);
+
+  const sourceDir = path.join(projectRoot, 'refacil-sdd', 'changes', name);
+  if (!fs.existsSync(sourceDir)) {
+    console.error(`No existe el cambio '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  const date = new Date().toISOString().slice(0, 10);
+  const archiveDir = path.join(projectRoot, 'refacil-sdd', 'changes', 'archive');
+  const destDir = path.join(archiveDir, `${date}-${name}`);
+
+  if (fs.existsSync(destDir)) {
+    console.error(`Ya existe un archivo con ese nombre: refacil-sdd/changes/archive/${date}-${name}/`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(archiveDir, { recursive: true });
+  fs.renameSync(sourceDir, destDir);
+
+  if (!(!fs.existsSync(sourceDir) && fs.existsSync(destDir))) {
+    console.error('Error: la operación de archivado no se completó correctamente.');
+    process.exit(1);
+  }
+
+  console.log(`Cambio '${name}' archivado en refacil-sdd/changes/archive/${date}-${name}/`);
+}
+
+function cmdList(argv) {
+  const args = parseArgs(argv);
+  const wantJson = args.json === true;
+
+  autoMigrateOpenspec(projectRoot);
+
+  const changesDir = path.join(projectRoot, 'refacil-sdd', 'changes');
+  if (!fs.existsSync(changesDir)) {
+    if (wantJson) {
+      process.stdout.write(JSON.stringify([]) + '\n');
+    } else {
+      console.log('Sin cambios activos.');
+    }
+    return;
+  }
+
+  const entries = fs.readdirSync(changesDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && e.name !== 'archive');
+
+  const result = entries.map((e) => {
+    const reviewPassed = fs.existsSync(path.join(changesDir, e.name, '.review-passed'));
+    return { name: e.name, reviewPassed };
+  });
+
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(result) + '\n');
+  } else {
+    if (result.length === 0) {
+      console.log('Sin cambios activos.');
+      return;
+    }
+    console.log('Cambios activos en refacil-sdd/changes/:');
+    for (const item of result) {
+      const badge = item.reviewPassed ? '[reviewed]' : '[pending-review]';
+      console.log(`  ${item.name}  ${badge}`);
+    }
+  }
+}
+
+function cmdStatus(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+  const wantJson = args.json === true;
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd status <nombre-cambio> [--json]');
+    process.exit(1);
+  }
+
+  autoMigrateOpenspec(projectRoot);
+
+  const changeDir = path.join(projectRoot, 'refacil-sdd', 'changes', name);
+  if (!fs.existsSync(changeDir)) {
+    console.error(`No existe el cambio '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  // Verificar artefactos
+  const hasProposal = fs.existsSync(path.join(changeDir, 'proposal.md'));
+  const hasDesign = fs.existsSync(path.join(changeDir, 'design.md'));
+  const hasTasks = fs.existsSync(path.join(changeDir, 'tasks.md'));
+
+  // specs: specs.md existe OR specs/ dir con al menos un .md
+  let hasSpecs = false;
+  const specsMd = path.join(changeDir, 'specs.md');
+  const specsDir = path.join(changeDir, 'specs');
+  if (fs.existsSync(specsMd)) {
+    hasSpecs = true;
+  } else if (fs.existsSync(specsDir) && fs.statSync(specsDir).isDirectory()) {
+    const mdFiles = fs.readdirSync(specsDir).filter((f) => f.endsWith('.md'));
+    hasSpecs = mdFiles.length > 0;
+  }
+
+  const artifacts = {
+    proposal: hasProposal,
+    design: hasDesign,
+    tasks: hasTasks,
+    specs: hasSpecs,
+  };
+
+  // Parsear tasks.md
+  let taskStats = { total: 0, done: 0, pending: 0 };
+  if (hasTasks) {
+    const tasksContent = fs.readFileSync(path.join(changeDir, 'tasks.md'), 'utf8');
+    const matches = [...tasksContent.matchAll(/^- \[([ x])\]/gm)];
+    taskStats.total = matches.length;
+    taskStats.done = matches.filter((m) => m[1] === 'x').length;
+    taskStats.pending = taskStats.total - taskStats.done;
+  }
+
+  const reviewPassed = fs.existsSync(path.join(changeDir, '.review-passed'));
+
+  const ready = {
+    forApply: artifacts.proposal && artifacts.tasks,
+    forArchive: reviewPassed && taskStats.total > 0 && taskStats.pending === 0,
+  };
+
+  const status = {
+    name,
+    artifacts,
+    tasks: taskStats,
+    reviewPassed,
+    ready,
+  };
+
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(status) + '\n');
+  } else {
+    console.log(`Estado del cambio '${name}':`);
+    console.log('');
+    console.log('  Artefactos:');
+    for (const [key, val] of Object.entries(artifacts)) {
+      console.log(`    ${key.padEnd(10)} ${val ? 'OK' : 'FALTANTE'}`);
+    }
+    console.log('');
+    console.log('  Tasks:');
+    console.log(`    total:   ${taskStats.total}`);
+    console.log(`    hechas:  ${taskStats.done}`);
+    console.log(`    pendientes: ${taskStats.pending}`);
+    console.log('');
+    console.log(`  Review aprobado: ${reviewPassed ? 'Si' : 'No'}`);
+    console.log('');
+    console.log('  Listo para:');
+    console.log(`    apply:   ${ready.forApply ? 'Si' : 'No'}`);
+    console.log(`    archive: ${ready.forArchive ? 'Si' : 'No'}`);
+  }
+}
+
+function cmdMarkReviewed(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd mark-reviewed <nombre-cambio> --verdict <verdict> --summary "<resumen>" [--fail-count N] [--preexisting-count N] [--blockers]');
+    process.exit(1);
+  }
+
+  if (!args.verdict) {
+    console.error('Error: --verdict es requerido (ej: approved, approved-with-notes, rejected)');
+    process.exit(1);
+  }
+
+  if (!args.summary) {
+    console.error('Error: --summary es requerido');
+    process.exit(1);
+  }
+
+  autoMigrateOpenspec(projectRoot);
+
+  const changeDir = path.join(projectRoot, 'refacil-sdd', 'changes', name);
+  if (!fs.existsSync(changeDir)) {
+    console.error(`No existe el cambio '${name}' en refacil-sdd/changes/${name}/`);
+    process.exit(1);
+  }
+
+  const payload = {
+    verdict: args.verdict,
+    changeName: name,
+    summary: args.summary,
+    failCount: Number(args['fail-count'] || 0),
+    preexistingCount: Number(args['preexisting-count'] || 0),
+    blockers: args.blockers === true,
+    date: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(changeDir, '.review-passed'), JSON.stringify(payload, null, 2));
+  console.log(`Review marcado como aprobado para '${name}' (verdict: ${payload.verdict})`);
+}
+
+function cmdTasksUpdate(argv) {
+  const args = parseArgs(argv);
+  const name = args._positional[0];
+
+  if (!name) {
+    console.error('Uso: refacil-sdd-ai sdd tasks-update <nombre-cambio> --task N --done');
+    process.exit(1);
+  }
+
+  const taskN = Number(args.task);
+  if (!args.task || !Number.isInteger(taskN) || taskN <= 0) {
+    console.error('Error: --task debe ser un entero positivo (ej: --task 1)');
+    process.exit(1);
+  }
+
+  if (args.done !== true) {
+    console.error('Error: --done es requerido para marcar una task como completada');
+    process.exit(1);
+  }
+
+  autoMigrateOpenspec(projectRoot);
+
+  const tasksFile = path.join(projectRoot, 'refacil-sdd', 'changes', name, 'tasks.md');
+  if (!fs.existsSync(tasksFile)) {
+    console.error(`No existe tasks.md para el cambio '${name}'`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(tasksFile, 'utf8');
+  const matches = [...content.matchAll(/^(- \[[ x]\].*)/gm)];
+
+  if (taskN > matches.length) {
+    console.error(`Error: task ${taskN} no encontrada (el archivo tiene ${matches.length} task(s))`);
+    process.exit(1);
+  }
+
+  const targetMatch = matches[taskN - 1];
+  const originalLine = targetMatch[1];
+  // Reemplazar [ ] por [x] (idempotente: [x] queda [x])
+  const updatedLine = originalLine.replace(/^- \[ \]/, '- [x]');
+
+  // Reemplazar solo la primera ocurrencia exacta de la línea original (en la posición correcta)
+  let replaced = false;
+  let count = 0;
+  const newContent = content.replace(/^(- \[[ x]\].*)/gm, (match) => {
+    count++;
+    if (count === taskN && !replaced) {
+      replaced = true;
+      return updatedLine;
+    }
+    return match;
+  });
+
+  fs.writeFileSync(tasksFile, newContent, 'utf8');
+  console.log(`Task ${taskN} de '${name}' marcada como completada.`);
+}
+
+function sddHelp() {
+  console.log(`
+  refacil-sdd-ai sdd — Gestión de artefactos SDD-AI
+
+  Subcomandos:
+    sdd new-change <nombre>            Crea un nuevo cambio con los 4 artefactos scaffold
+    sdd archive <nombre>               Archiva un cambio completado a refacil-sdd/changes/archive/
+    sdd list [--json]                  Lista cambios activos con estado de review
+    sdd status <nombre> [--json]       Muestra estado de artefactos y tasks de un cambio
+    sdd mark-reviewed <nombre>         Escribe .review-passed con veredicto y resumen
+      --verdict <v>                      Veredicto (ej: approved, approved-with-notes, rejected)
+      --summary "<texto>"                Resumen del review (requerido)
+      [--fail-count N]                   Número de fallos encontrados
+      [--preexisting-count N]            Número de issues preexistentes
+      [--blockers]                       Indica si hay blockers
+    sdd tasks-update <nombre>          Marca una task como completada en tasks.md
+      --task N                           Número de task (1-indexed)
+      --done                             Confirma que la task está hecha
+    sdd validate-name <nombre>         Valida el formato del nombre de un cambio
+
+  Notas:
+    - Los nombres de cambio deben empezar con minúscula y usar solo [a-z0-9-]
+    - Si existe openspec/ y no existe refacil-sdd/, se migra automáticamente
+  `);
+}
+
+// --- Dispatcher ---
+
+function handleSdd(sub, argv) {
+  const args = argv || [];
+
+  switch (sub) {
+    case 'new-change':
+      cmdNewChange(args);
+      break;
+    case 'archive':
+      cmdArchive(args);
+      break;
+    case 'list':
+      cmdList(args);
+      break;
+    case 'status':
+      cmdStatus(args);
+      break;
+    case 'mark-reviewed':
+      cmdMarkReviewed(args);
+      break;
+    case 'tasks-update':
+      cmdTasksUpdate(args);
+      break;
+    case 'validate-name':
+      cmdValidateName(args);
+      break;
+    default:
+      sddHelp();
+      process.exit(1);
+  }
+}
+
+module.exports = { handleSdd, parseArgs, autoMigrateOpenspec, validateChangeName };