agentic-kdd 3.5.3 → 3.5.4

package/spec-gate.cjs

@@ -0,0 +1,179 @@
+/**
+ * Spec Gate — Step 2 of the enhanced aa: pipeline
+ *
+ * Brecha 1 cerrada: antes de implementar cualquier cambio,
+ * verifica si el prompt pide modificar valores que existen
+ * en memoria como reglas de negocio HIGH confidence.
+ *
+ * Ejemplo: "cambia trial_days de 14 a 7"
+ * → Memoria tiene: "trial_days = 14 SPEC (HIGH)"
+ * → Spec Gate detecta la contradicción → STOP con explicación
+ */
+
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+
+const safe = (fn, fb = null) => { try { return fn(); } catch { return fb; } };
+
+function openDB(projectRoot) {
+  const dbPath = path.join(projectRoot, '.agentic/memoria.db');
+  if (!fs.existsSync(dbPath)) return null;
+  try { return new (require('better-sqlite3'))(dbPath); } catch { return null; }
+}
+
+/**
+ * Extrae valores numéricos y strings del prompt.
+ * Detecta patrones como "cambia X de 14 a 7", "set X to 7", "X = 7"
+ */
+function extractValuesFromPrompt(prompt) {
+  const changes = [];
+
+  // "cambia X de N a M" / "change X from N to M"
+  const fromTo = prompt.matchAll(/(?:cambia|change|update|modify)\s+(\w+)\s+(?:de|from)\s+([\d.]+)\s+(?:a|to)\s+([\d.]+)/gi);
+  for (const m of fromTo) {
+    changes.push({ field: m[1], from: m[2], to: m[3] });
+  }
+
+  // "X = N" / "X: N"
+  const assignments = prompt.matchAll(/(\w+(?:_\w+)*)\s*[=:]\s*([\d.]+)/g);
+  for (const m of assignments) {
+    changes.push({ field: m[1], value: m[2] });
+  }
+
+  // Numbers in context of known business fields
+  const businessFields = [
+    'trial_days', 'trial_period', 'trial',
+    'discount', 'yearly_discount',
+    'password', 'min_password', 'password_min',
+    'invoice_prefix', 'invoice_number',
+    'max_users', 'max_api_calls', 'max_storage',
+    'rate_limit', 'timeout', 'retries',
+  ];
+
+  businessFields.forEach(field => {
+    const regex = new RegExp(`${field}[^\\d]*(\\d+)`, 'gi');
+    const matches = prompt.matchAll(regex);
+    for (const m of matches) {
+      changes.push({ field, value: m[1] });
+    }
+  });
+
+  return changes;
+}
+
+/**
+ * Verifica si el cambio pedido contradice una regla en memoria.
+ */
+function checkAgainstMemory(db, changes) {
+  const violations = [];
+
+  changes.forEach(change => {
+    const fieldLower = (change.field || '').toLowerCase();
+
+    // Search for HIGH/MEDIA confidence nodes related to this field
+    const nodes = safe(() =>
+      db.prepare(`
+        SELECT id, titulo, contenido, confianza, area
+        FROM nodos
+        WHERE estado = 'ACTIVO'
+          AND confianza IN ('ALTA', 'MEDIA')
+          AND (
+            titulo LIKE ? OR contenido LIKE ?
+            OR titulo LIKE ? OR contenido LIKE ?
+          )
+        LIMIT 5
+      `).all(
+        `%${fieldLower}%`, `%${fieldLower}%`,
+        `%${change.field}%`, `%${change.field}%`
+      )
+    ) || [];
+
+    nodes.forEach(node => {
+      const content = (node.titulo + ' ' + node.contenido).toLowerCase();
+
+      // Check if memory contains a specific value for this field
+      const valueInMemory = content.match(new RegExp(`${fieldLower}[^\\d]*(\\d+)`, 'i'));
+      if (valueInMemory && change.to && valueInMemory[1] !== change.to) {
+        violations.push({
+          field:       change.field,
+          from:        change.from,
+          to:          change.to,
+          memory_says: valueInMemory[1],
+          node_id:     node.id,
+          confidence:  node.confianza,
+          rule:        node.titulo.substring(0, 80),
+          severity:    node.confianza === 'ALTA' ? 'STOP' : 'WARN',
+        });
+      }
+    });
+  });
+
+  return violations;
+}
+
+/**
+ * Main: run spec gate check against a prompt.
+ */
+function runSpecGate(prompt, projectRoot) {
+  projectRoot = projectRoot || process.cwd();
+  const db = openDB(projectRoot);
+
+  if (!db) return { passed: true, reason: 'No DB — skipping spec gate' };
+
+  const changes = extractValuesFromPrompt(prompt);
+  if (changes.length === 0) return { passed: true, reason: 'No value changes detected in prompt' };
+
+  const violations = checkAgainstMemory(db, changes);
+  db.close();
+
+  if (violations.length === 0) {
+    return { passed: true, changes_checked: changes.length };
+  }
+
+  const stops = violations.filter(v => v.severity === 'STOP');
+  const warns = violations.filter(v => v.severity === 'WARN');
+
+  return {
+    passed:     stops.length === 0,
+    violations,
+    stops,
+    warns,
+    message: stops.length > 0
+      ? `SPEC GATE STOP: ${stops.map(v =>
+          `"${v.field}" in memory = ${v.memory_says} but prompt requests ${v.to} — contradicts ${v.confidence} confidence rule: "${v.rule}"`
+        ).join('; ')}`
+      : `SPEC GATE WARN: ${warns.map(v =>
+          `"${v.field}" change may contradict memory rule: "${v.rule}"`
+        ).join('; ')}`,
+  };
+}
+
+if (require.main === module) {
+  const prompt = process.argv.slice(2).join(' ');
+  if (!prompt) {
+    console.log('Usage: node spec-gate.cjs "your prompt here"');
+    process.exit(0);
+  }
+  const result = runSpecGate(prompt, process.cwd());
+  if (!result.passed) {
+    console.log('\n🛑 SPEC GATE STOP');
+    console.log(result.message);
+    console.log('\nViolations:');
+    result.violations.forEach(v => {
+      console.log(`  ${v.severity} — ${v.field}: memory says ${v.memory_says}, prompt says ${v.to}`);
+      console.log(`  Rule: "${v.rule}" (${v.confidence})`);
+    });
+    process.exit(1);
+  } else if (result.warns?.length > 0) {
+    console.log('\n⚠️  SPEC GATE WARN');
+    console.log(result.message);
+    process.exit(0);
+  } else {
+    console.log(`✅ SPEC GATE PASS (checked ${result.changes_checked || 0} value changes)`);
+    process.exit(0);
+  }
+}
+
+module.exports = { runSpecGate, extractValuesFromPrompt };

package/src/mcp-setup.js

@@ -59,6 +59,7 @@ async function mcpSetup(projectPath, opts = {}) {
     cursorConfig.mcpServers['agentic-kdd'] = {
       command: 'node',
       args: [serverPath],
+      env: { PROJECT_ROOT: path.resolve(projectPath) },
     };
 
     fs.writeFileSync(cursorMcpFile, JSON.stringify(cursorConfig, null, 2));

package/tdd-gate.cjs

@@ -93,11 +93,17 @@ function runTests(command, projectRoot, testFile = null) {
   let exitCode = 0;
 
   try {
+    // Windows: use cmd.exe, Unix: use sh
+    const isWin = process.platform === 'win32';
+    const shell = isWin ? 'cmd.exe' : 'sh';
+    const shellFlag = isWin ? '/c' : '-c';
+    const shellCmd = isWin ? fullCmd : fullCmd + ' 2>&1';
+
     const result = spawnSync(
-      'sh', ['-c', fullCmd + ' 2>&1'],
+      shell, [shellFlag, shellCmd],
       { cwd: projectRoot, timeout: 120000, stdio: 'pipe', encoding: 'utf8' }
     );
-    output = result.stdout || '';
+    output = (result.stdout || '') + (isWin ? (result.stderr || '') : '');
     errorOutput = result.stderr || '';
     exitCode = result.status ?? 1;
   } catch (err) {
@@ -344,6 +350,46 @@ function runSelfHealingLoop(opts) {
 
     if (result.allPassed) {
       console.log(`\n[TDD-GATE] ✅ PASS en iteración ${iteration}`);
+
+      // Auto-register passing tests as contract candidates
+      try {
+        const contractGuardPath = require('path').join(__dirname, 'contract-guard.cjs');
+        const cg = require(contractGuardPath);
+        const dbPath = require('path').join(projectRoot || process.cwd(), '.agentic/memoria.db');
+        const DB = (() => {
+          try { return new (require('better-sqlite3'))(dbPath); } catch { return null; }
+        })();
+        if (DB && cg && typeof cg.registerPassingTests === 'function') {
+          cg.registerPassingTests(DB, { passed: result.passed, total: result.total, area: area || 'global', command });
+          console.log(`[TDD-GATE] 📋 Contracts: ${result.passed} tests → candidates`);
+        }
+
+        // Auto-register protected behavior snapshot
+        try {
+          const rgPath = require('path').join(__dirname, 'regression-guard.cjs');
+          if (require('fs').existsSync(rgPath)) {
+            const rg = require(rgPath);
+            const DB2 = (() => {
+              try { return new (require('better-sqlite3'))(dbPath); } catch { return null; }
+            })();
+            if (DB2) {
+              const behavior = rg.registerBehavior(DB2, {
+                module:      area || 'global',
+                files:       [],
+                testFiles:   [],
+                projectRoot: projectRoot || process.cwd(),
+              });
+              if (behavior) {
+                console.log(`[TDD-GATE] 🛡️  Behavior: [${behavior.module}] ${behavior.confidence} (cycle ${behavior.pass_count})`);
+              }
+              DB2.close();
+            }
+          }
+        } catch(e) { /* regression guard optional */ }
+
+        if (DB) DB.close();
+      } catch(e) { /* contract guard optional */ }
+
       break;
     }