pumuki-ast-hooks 5.6.7 → 5.6.9

package/scripts/hooks-system/bin/__tests__/cli.spec.js

@@ -8,4 +8,137 @@ describe('cli', () => {
   it('should be valid JavaScript', () => {
     expect(() => require.resolve('../cli.js')).not.toThrow();
   });
+
+  it('should expose proposeHumanIntent and infer goal from recent commits', () => {
+    const childProcess = require('child_process');
+
+    const originalExecSync = childProcess.execSync;
+    childProcess.execSync = (cmd) => {
+      const command = String(cmd);
+      if (command.includes('git log') && command.includes('--pretty=%s')) {
+        return 'fix: token economy docs, assets and MCP outputs\nRelease: 2026-01-11\n';
+      }
+      return '';
+    };
+
+    const { proposeHumanIntent } = require('../cli.js');
+    expect(typeof proposeHumanIntent).toBe('function');
+
+    const proposed = proposeHumanIntent({
+      evidence: { ai_gate: { status: 'ALLOWED' }, platforms: {} },
+      branch: 'develop',
+      stagedFiles: []
+    });
+    expect(proposed && typeof proposed.primary_goal).toBe('string');
+    expect(proposed.primary_goal.toLowerCase()).toContain('token economy');
+
+    childProcess.execSync = originalExecSync;
+  });
+
+  it('wrap-up should auto-save human_intent by default', () => {
+    const fs = require('fs');
+    const childProcess = require('child_process');
+
+    const originalConsoleLog = console.log;
+    const logSpy = jest.fn();
+    console.log = logSpy;
+
+    const originalArgv = process.argv;
+    const originalExecSync = childProcess.execSync;
+
+    const existsSyncSpy = jest.spyOn(fs, 'existsSync').mockImplementation(() => true);
+    const readFileSyncSpy = jest.spyOn(fs, 'readFileSync').mockImplementation(() => JSON.stringify({ ai_gate: { status: 'ALLOWED' }, platforms: {} }));
+    const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
+
+    childProcess.execSync = (cmd) => {
+      const command = String(cmd);
+      if (command.includes('git rev-parse --show-toplevel')) {
+        return '/tmp/repo\n';
+      }
+      if (command.includes('git branch --show-current')) {
+        return 'main\n';
+      }
+      if (command.includes('git diff --cached --name-only')) {
+        return '\n';
+      }
+      if (command.includes('git log') && command.includes('--pretty=%s')) {
+        return 'fix: token economy docs, assets and MCP outputs\n';
+      }
+      if (command.includes('node') && command.includes('intelligent-audit.js')) {
+        return '';
+      }
+      return '';
+    };
+
+    process.argv = ['node', 'cli.js', 'wrap-up'];
+    jest.resetModules();
+    const { commands } = require('../cli.js');
+    commands['wrap-up']();
+
+    expect(logSpy.mock.calls.map(c => String(c[0] || '')).join('\n')).toContain('auto-saved');
+    expect(writeFileSyncSpy).toHaveBeenCalled();
+    const written = writeFileSyncSpy.mock.calls.map(c => String(c[1] || '')).join('\n');
+    expect(written).toContain('"human_intent"');
+    expect(written.toLowerCase()).toContain('token economy');
+
+    console.log = originalConsoleLog;
+    process.argv = originalArgv;
+    childProcess.execSync = originalExecSync;
+    existsSyncSpy.mockRestore();
+    readFileSyncSpy.mockRestore();
+    writeFileSyncSpy.mockRestore();
+  });
+
+  it('wrap-up should not save when --no-save is provided', () => {
+    const fs = require('fs');
+    const childProcess = require('child_process');
+
+    const originalConsoleLog = console.log;
+    const logSpy = jest.fn();
+    console.log = logSpy;
+
+    const originalArgv = process.argv;
+    const originalExecSync = childProcess.execSync;
+
+    const existsSyncSpy = jest.spyOn(fs, 'existsSync').mockImplementation(() => true);
+    const readFileSyncSpy = jest.spyOn(fs, 'readFileSync').mockImplementation(() => JSON.stringify({ ai_gate: { status: 'ALLOWED' }, platforms: {} }));
+    const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
+
+    childProcess.execSync = (cmd) => {
+      const command = String(cmd);
+      if (command.includes('git rev-parse --show-toplevel')) {
+        return '/tmp/repo\n';
+      }
+      if (command.includes('git branch --show-current')) {
+        return 'main\n';
+      }
+      if (command.includes('git diff --cached --name-only')) {
+        return '\n';
+      }
+      if (command.includes('git log') && command.includes('--pretty=%s')) {
+        return 'fix: token economy docs, assets and MCP outputs\n';
+      }
+      if (command.includes('node') && command.includes('intelligent-audit.js')) {
+        return '';
+      }
+      return '';
+    };
+
+    process.argv = ['node', 'cli.js', 'wrap-up', '--no-save'];
+    jest.resetModules();
+    const { commands } = require('../cli.js');
+    commands['wrap-up']();
+
+    expect(logSpy.mock.calls.map(c => String(c[0] || '')).join('\n')).toContain('proposal only');
+    expect(writeFileSyncSpy).toHaveBeenCalled();
+    const written = writeFileSyncSpy.mock.calls.map(c => String(c[1] || '')).join('\n');
+    expect(written).not.toContain('"human_intent"');
+
+    console.log = originalConsoleLog;
+    process.argv = originalArgv;
+    childProcess.execSync = originalExecSync;
+    existsSyncSpy.mockRestore();
+    readFileSyncSpy.mockRestore();
+    writeFileSyncSpy.mockRestore();
+  });
 });

package/scripts/hooks-system/bin/cli.js

@@ -11,8 +11,8 @@ const fs = require('fs');
 const path = require('path');
 const env = require('../config/env');
 
-const command = process.argv[2];
-const args = process.argv.slice(3);
+let command = process.argv[2];
+let args = process.argv.slice(3);
 
 const HOOKS_ROOT = path.join(__dirname, '..');
 
@@ -65,6 +65,15 @@ function getStagedFilesSafe() {
   }
 }
 
+function getRecentCommitSubjects(limit = 10) {
+  try {
+    const output = execSync(`git log -n ${limit} --pretty=%s`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return String(output || '').split('\n').map(s => s.trim()).filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
 function proposeHumanIntent({ evidence, branch, stagedFiles }) {
   const safeEvidence = (evidence && typeof evidence === 'object') ? evidence : {};
   const safeBranch = branch || safeEvidence.current_context?.current_branch || 'unknown';
@@ -91,6 +100,20 @@ function proposeHumanIntent({ evidence, branch, stagedFiles }) {
   const platformLabel = platforms.length > 0 ? platforms.join('+') : (detectedPlatforms.length > 0 ? detectedPlatforms.join('+') : 'repo');
 
   let primaryGoal = `Continue work on ${platformLabel} changes`;
+  if (platformLabel === 'repo' && staged.length === 0 && detectedPlatforms.length === 0) {
+    const subjects = getRecentCommitSubjects(12).join(' | ').toLowerCase();
+    if (subjects.includes('token economy')) {
+      primaryGoal = 'Continue token economy improvements (docs + MCP outputs)';
+    } else if (subjects.includes('release') || subjects.includes('publish') || subjects.includes('version')) {
+      primaryGoal = 'Continue release/publish workflow maintenance';
+    } else if (subjects.includes('gitflow')) {
+      primaryGoal = 'Continue Git Flow automation maintenance';
+    } else if (subjects.includes('mcp')) {
+      primaryGoal = 'Continue MCP automation maintenance';
+    } else if (subjects.includes('readme') || subjects.includes('docs')) {
+      primaryGoal = 'Continue documentation improvements';
+    }
+  }
   if (gateStatus === 'BLOCKED') {
     primaryGoal = `Unblock AI gate by fixing ${platformLabel} violations`;
   }
@@ -250,7 +273,33 @@ const commands = {
       const stagedFiles = getStagedFilesSafe();
       const proposed = proposeHumanIntent({ evidence, branch, stagedFiles });
 
-      console.log('\n💡 Suggested Human Intent (proposal only):');
+      const shouldSave = !process.argv.includes('--no-save');
+      if (shouldSave) {
+        const now = new Date();
+        const expiresAt = new Date(Date.now() + 24 * 3600000).toISOString();
+        evidence.human_intent = {
+          primary_goal: proposed.primary_goal,
+          secondary_goals: proposed.secondary_goals || [],
+          non_goals: proposed.non_goals || [],
+          constraints: proposed.constraints || [],
+          confidence_level: proposed.confidence_level || 'medium',
+          set_by: 'wrap-up',
+          set_at: now.toISOString(),
+          expires_at: expiresAt,
+          preserved_at: now.toISOString(),
+          preservation_count: 0
+        };
+
+        try {
+          fs.writeFileSync(evidencePath, JSON.stringify(evidence, null, 2), 'utf8');
+        } catch (e) {
+          if (process.env.DEBUG) {
+            process.stderr.write(`[wrap-up] Failed to save human_intent: ${e && e.message ? e.message : String(e)}\n`);
+          }
+        }
+      }
+
+      console.log(`\n💡 Suggested Human Intent (${shouldSave ? 'auto-saved' : 'proposal only'}):`);
       console.log(`  Primary Goal: ${proposed.primary_goal}`);
       console.log(`  Secondary:    ${(proposed.secondary_goals || []).join(', ') || '(none)'}`);
       console.log(`  Constraints:  ${(proposed.constraints || []).join(', ') || '(none)'}`);
@@ -259,9 +308,14 @@ const commands = {
       console.log(`  Gate:         ${(proposed.derived_from && proposed.derived_from.gate_status) || '(unknown)'}`);
 
       const suggestedCmd = `ast-hooks intent set --goal="${proposed.primary_goal}" --confidence=${proposed.confidence_level || 'medium'} --expires=24h`;
-      console.log('\n✅ To apply it, run:');
-      console.log(`  ${suggestedCmd}`);
-      console.log('');
+      if (shouldSave) {
+        console.log('\n✅ Saved to .AI_EVIDENCE.json');
+        console.log('');
+      } else {
+        console.log('\n✅ To apply it, run:');
+        console.log(`  ${suggestedCmd}`);
+        console.log('');
+      }
     } catch (error) {
       if (process.env.DEBUG) {
         process.stderr.write(`[wrap-up] Intent suggestion failed: ${error && error.message ? error.message : String(error)}\n`);
@@ -569,12 +623,15 @@ Documentation:
   },
 
   version: () => {
-    const pkg = require('../package.json');
+    const pkg = require(path.join(__dirname, '../../../package.json'));
     console.log(`v${pkg.version}`);
   }
 };
 
-if (require.main === module) {
+function runCli(argv = process.argv) {
+  command = argv[2];
+  args = argv.slice(3);
+
   if (!command || !commands[command]) {
     commands.help();
     process.exit(command ? 1 : 0);
@@ -582,4 +639,8 @@ if (require.main === module) {
   commands[command]();
 }
 
-module.exports = { commands };
+if (require.main === module) {
+  runCli(process.argv);
+}
+
+module.exports = { commands, proposeHumanIntent, runCli };

package/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js

@@ -715,11 +715,19 @@ function cleanupStaleBranches(params) {
  */
 async function autoExecuteAIStart(params) {
     const useCase = getCompositionRoot().getAutoExecuteAIStartUseCase();
+    const tokenEconomyRule = 'TOKEN_ECONOMY: Prioritize token/cost efficiency. Batch related checks, avoid redundant scans, reuse cached context where possible, ask the user for missing info instead of exploring blindly, and keep responses concise.';
 
     try {
-        const result = await useCase.execute({
-            force: params.forceAnalysis || false
-        });
+        const orchestrator = getCompositionRoot().getOrchestrator();
+        const analysis = await orchestrator.analyzeContext();
+
+        const platforms = Array.isArray(analysis?.platforms)
+            ? analysis.platforms.map(p => (p && typeof p === 'object' ? (p.platform || p.name) : p)).filter(Boolean)
+            : [];
+
+        const confidence = Number.isFinite(analysis?.confidence) ? analysis.confidence : 0;
+
+        const result = await useCase.execute(platforms, confidence);
 
         if (result.action === 'auto-executed') {
             sendNotification(
@@ -731,6 +739,7 @@ async function autoExecuteAIStart(params) {
 
         return {
             success: true,
+            framework_rules: [tokenEconomyRule],
             ...result
         };
 
@@ -738,6 +747,7 @@ async function autoExecuteAIStart(params) {
         return {
             success: false,
             action: 'error',
+            framework_rules: [tokenEconomyRule],
             message: `Failed to execute AI Start: ${error.message}`
         };
     }
@@ -1144,6 +1154,9 @@ function extractCriticalPatterns(content, platform) {
         patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO composición > herencia', severity: 'MANDATORY' });
     }
 
+    /**
+     * Returns the patterns for the given platforms.
+     */
     return patterns;
 }
 
@@ -1306,6 +1319,7 @@ async function aiGateCheck() {
         const normalizedPlatforms = Array.from(new Set(platformsForRules));
 
         let mandatoryRules = null;
+        const tokenEconomyRule = 'TOKEN_ECONOMY: Prioritize token/cost efficiency. Batch related checks, avoid redundant scans, reuse cached context where possible, ask the user for missing info instead of exploring blindly, and keep responses concise.';
         try {
             const rulesData = await loadPlatformRules(normalizedPlatforms);
             const rulesSample = rulesData.criticalRules.slice(0, 5).map(r => r.rule || r);
@@ -1316,7 +1330,8 @@ async function aiGateCheck() {
                 rulesLoaded: Object.keys(rulesData.rules),
                 totalRulesCount: rulesCount,
                 rulesSample,
-                proofOfRead: `✅ VERIFIED: ${rulesCount} critical rules loaded from ${Object.keys(rulesData.rules).join(', ')}`
+                proofOfRead: `✅ VERIFIED: ${rulesCount} critical rules loaded from ${Object.keys(rulesData.rules).join(', ')}`,
+                framework_rules: [tokenEconomyRule]
             };
         } catch (error) {
             if (process.env.DEBUG) {
@@ -1328,7 +1343,8 @@ async function aiGateCheck() {
                 criticalRules: [],
                 rulesLoaded: [],
                 status: 'FAILED_TO_LOAD',
-                error: `Failed to load rules content: ${error && error.message ? error.message : String(error)}`
+                error: `Failed to load rules content: ${error && error.message ? error.message : String(error)}`,
+                framework_rules: [tokenEconomyRule]
             };
         }
 
@@ -1373,7 +1389,7 @@ async function aiGateCheck() {
                 : `✅ ALLOWED: Gate check passed with ${warnings.length} warning(s).`,
             instructions: finalBlocked
                 ? 'Fix violations before proceeding. Run ai-start if needed.'
-                : `✅ ${mandatoryRules.totalRulesCount} RULES LOADED. Sample: ${mandatoryRules.rulesSample.slice(0, 2).join(' | ')}... Review ALL rules in mandatory_rules.criticalRules before ANY code generation.`,
+                : `✅ ${mandatoryRules.totalRulesCount} RULES LOADED. Sample: ${mandatoryRules.rulesSample.slice(0, 2).join(' | ')}... Review ALL rules in mandatory_rules.criticalRules before ANY code generation. Also follow mandatory_rules.framework_rules (token economy).`,
             cognitive_context: humanIntent?.primary_goal
                 ? `🎯 USER INTENT: ${humanIntent.primary_goal} (confidence: ${humanIntent.confidence_level || 'unset'})`
                 : null,
@@ -1444,18 +1460,25 @@ async function aiGateCheck() {
             platforms: ['backend', 'frontend', 'ios', 'android'],
             criticalRules: [],
             rulesLoaded: [],
+            framework_rules: ['TOKEN_ECONOMY: Prioritize token/cost efficiency. Batch related checks, avoid redundant scans, reuse cached context where possible, ask the user for missing info instead of exploring blindly, and keep responses concise.'],
             warning: '⚠️ AI MUST read and follow these rules before ANY code generation or modification',
             error: 'Rules could not be loaded due to timeout'
         },
         summary: '🚫 BLOCKED: Gate check timed out.',
-        instructions: 'DO NOT proceed with user task. Retry the gate check.'
+        instructions: 'DO NOT proceed with user task. Retry the gate check.',
+        cognitive_context: null,
+        human_intent: null,
+        semantic_snapshot: null,
+        auto_intent: null,
+        session: {
+            id: gateSession.sessionId,
+            checkCount: gateSession.checkCount,
+            validFor: gateSession.GATE_VALIDITY_MS / 60000 + ' minutes'
+        }
     };
     gateSession.recordCheck(timeoutResult);
     return timeoutResult;
 }
-/**
- * Read platform rules handler - returns critical rules for a specific platform
- */
 async function readPlatformRulesHandler(params) {
     const platform = params.platform;
     if (!platform) {
@@ -1693,10 +1716,12 @@ function suggestHumanIntent() {
  */
 function preFlightCheck(params) {
     const { action_type, target_file, proposed_code, bypass_tdd } = params;
+    const tokenEconomyRule = 'TOKEN_ECONOMY: Prioritize token/cost efficiency. Batch related checks, avoid redundant scans, reuse cached context where possible, ask the user for missing info instead of exploring blindly, and keep responses concise.';
 
     if (!action_type || !target_file) {
         return {
             success: false,
+            framework_rules: [tokenEconomyRule],
             error: 'action_type and target_file are required',
             hint: 'Call with: { action_type: "edit"|"create_file", target_file: "/path/to/file.ts", proposed_code: "..." }'
         };
@@ -1716,6 +1741,7 @@ function preFlightCheck(params) {
             success: false,
             allowed: false,
             blocked: true,
+            framework_rules: [tokenEconomyRule],
             reason: validation.enforcement_message,
             violations: validation.violations,
             tdd_status: validation.tddStatus,
@@ -1741,6 +1767,7 @@ function preFlightCheck(params) {
                     success: false,
                     allowed: false,
                     blocked: true,
+                    framework_rules: [tokenEconomyRule],
                     reason: '🚫 AST INTELLIGENCE BLOCKED: Critical/High violations detected in proposed code',
                     ast_violations: blocking,
                     ast_summary: astAnalysis.summary,
@@ -1765,6 +1792,7 @@ function preFlightCheck(params) {
             success: true,
             allowed: true,
             has_warnings: true,
+            framework_rules: [tokenEconomyRule],
             warnings: validation.violations.filter(v => v.severity === 'WARNING'),
             ast_analysis: astAnalysis,
             message: '⚠️ Proceed with caution - review warnings',
@@ -1777,6 +1805,7 @@ function preFlightCheck(params) {
     return {
         success: true,
         allowed: true,
+        framework_rules: [tokenEconomyRule],
         message: '✅ Pre-flight check PASSED - proceed with implementation',
         ast_analysis: astAnalysis,
         tdd_status: validation.tddStatus,

package/scripts/hooks-system/infrastructure/watchdog/__tests__/.audit-reports/token-monitor.log

@@ -7,3 +7,9 @@
 {"timestamp":"2026-01-11T00:48:11.264Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"ok","percentUsed":10,"tokensUsed":100000,"maxTokens":1000000,"source":"realtime","stale":false},"context":{"message":"Result level=ok percent=10% used=100000/1000000 source=realtime"}}
 {"timestamp":"2026-01-11T00:48:11.267Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"warning","percentUsed":91,"tokensUsed":910000,"maxTokens":1000000,"source":"fallback","stale":false},"context":{"message":"Result level=warning percent=91% used=910000/1000000 source=fallback"}}
 {"timestamp":"2026-01-11T00:48:11.267Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"critical","percentUsed":98,"tokensUsed":980000,"maxTokens":1000000,"source":"realtime","stale":true},"context":{"message":"Result level=critical percent=98% used=980000/1000000 source=realtime (stale)"}}
+{"timestamp":"2026-01-11T14:18:34.198Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"ok","percentUsed":10,"tokensUsed":100000,"maxTokens":1000000,"source":"realtime","stale":false},"context":{"message":"Result level=ok percent=10% used=100000/1000000 source=realtime"}}
+{"timestamp":"2026-01-11T14:18:34.200Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"warning","percentUsed":91,"tokensUsed":910000,"maxTokens":1000000,"source":"fallback","stale":false},"context":{"message":"Result level=warning percent=91% used=910000/1000000 source=fallback"}}
+{"timestamp":"2026-01-11T14:18:34.201Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"critical","percentUsed":98,"tokensUsed":980000,"maxTokens":1000000,"source":"realtime","stale":true},"context":{"message":"Result level=critical percent=98% used=980000/1000000 source=realtime (stale)"}}
+{"timestamp":"2026-01-11T18:11:25.198Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"ok","percentUsed":10,"tokensUsed":100000,"maxTokens":1000000,"source":"realtime","stale":false},"context":{"message":"Result level=ok percent=10% used=100000/1000000 source=realtime"}}
+{"timestamp":"2026-01-11T18:11:25.199Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"warning","percentUsed":91,"tokensUsed":910000,"maxTokens":1000000,"source":"fallback","stale":false},"context":{"message":"Result level=warning percent=91% used=910000/1000000 source=fallback"}}
+{"timestamp":"2026-01-11T18:11:25.199Z","level":"info","component":"TokenMonitor","event":"TOKEN_MONITOR_RESULT","data":{"level":"critical","percentUsed":98,"tokensUsed":980000,"maxTokens":1000000,"source":"realtime","stale":true},"context":{"message":"Result level=critical percent=98% used=980000/1000000 source=realtime (stale)"}}