pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/hooks/skill-activation-prompt.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const rulesPath = path.join(projectDir, '.cursor', 'ai-skills', 'skill-rules.json');
+const mdcRulesDir = path.join(projectDir, '.cursor', 'rules');
+const debugLogPath = path.join(projectDir, '.audit_tmp', 'skill-activation-debug.log');
+
+function appendDebugLog(message) {
+    try {
+        const dir = path.dirname(debugLogPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const timestamp = new Date().toISOString();
+        fs.appendFileSync(debugLogPath, `[${timestamp}] ${message}\n`);
+    } catch (error) {
+        process.stderr.write(`Failed to write debug log: ${error.message}\n`);
+    }
+}
+
+function loadMdcRules() {
+    const mdcFiles = {
+        backend: 'rulesbackend.mdc',
+        frontend: 'rulesfront.mdc',
+        ios: 'rulesios.mdc',
+        android: 'rulesandroid.mdc'
+    };
+
+    const loaded = [];
+
+    for (const [platform, filename] of Object.entries(mdcFiles)) {
+        const filePath = path.join(mdcRulesDir, filename);
+        try {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf8');
+                const lines = content.split('\n').length;
+                loaded.push({ platform, filename, lines });
+                appendDebugLog(`Loaded .mdc rule: ${filename} (${lines} lines)`);
+            }
+        } catch (error) {
+            appendDebugLog(`Failed to load ${filename}: ${error.message}`);
+        }
+    }
+
+    return loaded;
+}
+
+function sendMacNotification(title, message) {
+    if (process.platform !== 'darwin') {
+        return;
+    }
+
+    const enabled = process.env.HOOK_GUARD_ENABLE_SKILL_ACTIVATION !== '0';
+    if (!enabled) {
+        appendDebugLog('Notifications disabled via HOOK_GUARD_ENABLE_SKILL_ACTIVATION');
+        return;
+    }
+
+    const terminalNotifierPath = [
+        '/opt/homebrew/bin/terminal-notifier',
+        '/usr/local/bin/terminal-notifier',
+        '/usr/bin/terminal-notifier'
+    ].find(p => fs.existsSync(p));
+
+    if (terminalNotifierPath) {
+        try {
+            const { spawnSync } = require('child_process');
+            const args = [
+                '-title', title,
+                '-message', message,
+                '-sound', 'Hero',
+                '-group', 'hook-system-skill-activation',
+                '-ignoreDnD'
+            ];
+            const result = spawnSync(terminalNotifierPath, args, {
+                stdio: 'ignore',
+                timeout: 5000
+            });
+            if (result.status === 0) {
+                appendDebugLog(`Sent macOS notification via terminal-notifier: ${title}`);
+                return;
+            } else {
+                appendDebugLog(`terminal-notifier failed with status ${result.status}, falling back to osascript`);
+            }
+        } catch (error) {
+            appendDebugLog(`terminal-notifier error: ${error.message}, falling back to osascript`);
+        }
+    }
+
+    try {
+        const escapedTitle = title.replace(/"/g, '\\"');
+        const escapedMessage = message.replace(/"/g, '\\"').replace(/\n/g, ' ');
+        const script = `display notification "${escapedMessage}" with title "${escapedTitle}" sound name "Hero"`;
+        execSync(`osascript -e '${script}'`, { stdio: 'ignore' });
+        appendDebugLog(`Sent macOS notification via osascript: ${title}`);
+    } catch (error) {
+        appendDebugLog(`Failed to send notification: ${error.message}`);
+    }
+}
+
+function printMatches(matchedSkills, mdcRules) {
+    if (matchedSkills.length === 0) {
+        return;
+    }
+
+    let output = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+    output += '🎯 SKILL ACTIVATION CHECK\n';
+    output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
+
+    const critical = matchedSkills.filter(s => s.config.priority === 'critical');
+    const high = matchedSkills.filter(s => s.config.priority === 'high');
+    const medium = matchedSkills.filter(s => s.config.priority === 'medium');
+    const low = matchedSkills.filter(s => s.config.priority === 'low');
+
+    if (critical.length > 0) {
+        output += '⚠️ CRITICAL SKILLS (REQUIRED):\n';
+        critical.forEach(s => output += `  → ${s.name}\n`);
+        output += '\n';
+    }
+
+    if (high.length > 0) {
+        output += '📚 RECOMMENDED SKILLS:\n';
+        high.forEach(s => output += `  → ${s.name}\n`);
+        output += '\n';
+    }
+
+    if (medium.length > 0) {
+        output += '💡 SUGGESTED SKILLS:\n';
+        medium.forEach(s => output += `  → ${s.name}\n`);
+        output += '\n';
+    }
+
+    if (low.length > 0) {
+        output += '📌 OPTIONAL SKILLS:\n';
+        low.forEach(s => output += `  → ${s.name}\n`);
+        output += '\n';
+    }
+
+    if (mdcRules.length > 0) {
+        output += '📋 REGLAS .MDC CARGADAS:\n';
+        mdcRules.forEach(rule => {
+            output += `  ✓ ${rule.platform}: ${rule.filename} (${rule.lines} líneas)\n`;
+        });
+        output += '\n';
+    }
+
+    output += 'ACTION: Use Skill tool BEFORE responding\n';
+    output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+
+    process.stdout.write(`${output}\n`);
+
+    const notificationTitle = critical.length > 0
+        ? '⚠️ Critical Skills Required'
+        : high.length > 0
+            ? '📚 Recommended Skills'
+            : '💡 Suggested Skills';
+
+    const notificationMessage = matchedSkills.slice(0, 3).map(s => s.name).join(', ');
+    sendMacNotification(notificationTitle, notificationMessage);
+}
+
+function main() {
+    try {
+        let input = '';
+        process.stdin.setEncoding('utf8');
+
+        process.stdin.on('data', chunk => {
+            input += chunk;
+        });
+
+        process.stdin.on('end', () => {
+            try {
+                const data = JSON.parse(input);
+                const prompt = (data.prompt || '').toLowerCase();
+
+                if (!fs.existsSync(rulesPath)) {
+                    appendDebugLog(`Skill rules not found at: ${rulesPath}`);
+                    process.exit(0);
+                }
+
+                const rulesContent = fs.readFileSync(rulesPath, 'utf8');
+                const rules = JSON.parse(rulesContent);
+
+                const matchedSkills = [];
+
+                for (const [skillName, config] of Object.entries(rules)) {
+                    if (!config.promptTriggers) {
+                        continue;
+                    }
+
+                    const triggers = config.promptTriggers;
+
+                    if (triggers.keywords) {
+                        const keywordMatch = triggers.keywords.some(kw =>
+                            prompt.includes(kw.toLowerCase())
+                        );
+                        if (keywordMatch) {
+                            matchedSkills.push({ name: skillName, matchType: 'keyword', config });
+                            continue;
+                        }
+                    }
+
+                    if (triggers.intentPatterns) {
+                        const intentMatch = triggers.intentPatterns.some(pattern => {
+                            try {
+                                const regex = new RegExp(pattern, 'i');
+                                return regex.test(prompt);
+                            } catch (error) {
+                                appendDebugLog(`Invalid regex pattern: ${pattern}`);
+                                return false;
+                            }
+                        });
+                        if (intentMatch) {
+                            matchedSkills.push({ name: skillName, matchType: 'intent', config });
+                        }
+                    }
+                }
+
+                const mdcRules = loadMdcRules();
+
+                if (matchedSkills.length > 0 || mdcRules.length > 0) {
+                    printMatches(matchedSkills, mdcRules);
+                    appendDebugLog(`Matched ${matchedSkills.length} skills, loaded ${mdcRules.length} .mdc rules`);
+                }
+
+                process.exit(0);
+            } catch (error) {
+                appendDebugLog(`Error processing hook input: ${error.message}`);
+                process.stderr.write(`Error in skill-activation-prompt hook: ${error.message}\n`);
+                process.exit(1);
+            }
+        });
+    } catch (error) {
+        appendDebugLog(`Fatal error: ${error.message}`);
+        process.stderr.write(`Fatal error in skill-activation-prompt hook: ${error.message}\n`);
+        process.exit(1);
+    }
+}
+
+main();

package/scripts/hooks-system/infrastructure/logging/UnifiedLoggerFactory.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+
+const UnifiedLogger = require('../../application/services/logging/UnifiedLogger');
+
+function createUnifiedLogger({
+    repoRoot = process.cwd(),
+    component = 'HookSystem',
+    consoleLevel = process.env.HOOK_LOG_CONSOLE_LEVEL || 'info',
+    fileLevel = process.env.HOOK_LOG_FILE_LEVEL || 'debug',
+    fileName = null,
+    defaultData = {}
+} = {}) {
+    const reportsDir = path.join(repoRoot, '.audit-reports');
+    fs.mkdirSync(reportsDir, { recursive: true });
+
+    const logFileName = fileName || `${component.replace(/\s+/g, '-').toLowerCase()}.log`;
+    const filePath = path.join(reportsDir, logFileName);
+
+    const maxSizeBytes = Number(process.env.HOOK_LOG_MAX_SIZE || 5 * 1024 * 1024);
+    const maxFiles = Number(process.env.HOOK_LOG_MAX_FILES || 5);
+
+    return new UnifiedLogger({
+        component,
+        console: {
+            enabled: true,
+            level: consoleLevel
+        },
+        file: {
+            enabled: true,
+            level: fileLevel,
+            path: filePath,
+            maxSizeBytes,
+            maxFiles
+        },
+        defaultData
+    });
+}
+
+module.exports = { createUnifiedLogger };

package/scripts/hooks-system/infrastructure/logging/__tests__/logging.spec.js

@@ -0,0 +1,9 @@
+describe('logging', () => {
+  describe('UnifiedLoggerFactory', () => {
+    it('should export createUnifiedLogger function', () => {
+      const { createUnifiedLogger } = require('../UnifiedLoggerFactory');
+      expect(createUnifiedLogger).toBeDefined();
+      expect(typeof createUnifiedLogger).toBe('function');
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/mcp/README.md

@@ -0,0 +1,116 @@
+<p align="center">
+   <img src="../../assets/logo.png" alt="PUMUKI - AST Intelligence" width="150" />
+ </p>
+
+# MCP Server: AI Evidence Watcher
+
+## 🎯 Objetivo
+
+**Notificar automáticamente a la IA (no al usuario) cuando `.AI_EVIDENCE.json` está stale**, para que la IA pueda actualizar el evidence automáticamente sin intervención manual.
+
+## 🔄 Diferencia con Watchdog
+
+| Component | Propósito | Target |
+|-----------|-----------|--------|
+| **Watchdog** (`ai-watchdog.sh`) | Notificar a Carlos vía macOS | 👤 Usuario |
+| **MCP Server** (`evidence-watcher.js`) | Notificar a la IA vía Cursor | 🤖 IA |
+
+## 📡 Protocolo MCP (Model Context Protocol)
+
+El MCP permite a la IA en Cursor:
+1. **Leer recursos** (como el estado del evidence)
+2. **Llamar herramientas** (como check_evidence_status)
+
+**Sin MCP:**
+```
+Usuario → ai-start → actualiza evidence → IA puede trabajar
+```
+
+**Con MCP:**
+```
+IA detecta evidence stale vía MCP → IA actualiza automáticamente → Usuario trabaja directamente
+```
+
+## 🚀 Recursos Expuestos
+
+### `evidence://status`
+Estado actual del `.AI_EVIDENCE.json`:
+
+```json
+{
+  "status": "stale|fresh|missing|error",
+  "message": "Evidence is STALE (350s old, max 180s)",
+  "action": "Run: ai-start develop",
+  "age": 350,
+  "isStale": true,
+  "timestamp": "2025-11-06T14:33:45Z",
+  "session": "develop",
+  "currentBranch": "develop"
+}
+```
+
+## 🛠️ Herramientas Expuestas
+
+### `check_evidence_status`
+Chequea si el evidence está stale:
+
+**Input:** Ninguno  
+**Output:** Mismo que `evidence://status`
+
+## ⚙️ Configuración
+
+El MCP server se configura en `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "ai-evidence-watcher": {
+      "command": "node",
+      "args": [
+        "${workspaceFolder}/scripts/hooks-system/infrastructure/mcp/evidence-watcher.js"
+      ],
+      "env": {
+        "REPO_ROOT": "${workspaceFolder}"
+      }
+    }
+  }
+}
+```
+
+## 🧪 Testing
+
+```bash
+# Test manual (simula lo que hace Cursor)
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | \
+  node scripts/hooks-system/infrastructure/mcp/evidence-watcher.js
+
+# Expected output: initialize response
+
+echo '{"jsonrpc":"2.0","id":2,"method":"resources/read","params":{"uri":"evidence://status"}}' | \
+  REPO_ROOT=$(pwd) node scripts/hooks-system/infrastructure/mcp/evidence-watcher.js
+```
+
+## 📝 Cómo lo Usa la IA
+
+Cuando Cursor arranca:
+1. **Cursor inicia el MCP server** automáticamente
+2. **La IA consulta** `evidence://status` o llama `check_evidence_status`
+3. **Si está stale:** La IA puede:
+   - Avisar al usuario: "⚠️ Evidence stale, actualiza con ai-start develop"
+   - **Futuro:** Actualizar automáticamente el evidence (requiere tool de escritura)
+
+## 🔮 Futuras Mejoras
+
+1. **Tool `update_evidence`**: Permitir a la IA actualizar el evidence directamente
+2. **Push notifications**: En lugar de polling, usar `fswatch` para notificar cambios
+3. **Integración con rules**: Sugerir qué reglas .mdc leer según archivos modificados
+
+## 🐈 Pumuki Dice
+
+> **"Ahora la IA (yo) puede saber automáticamente cuando el evidence está viejo, sin que Carlos tenga que acordarse. ¡Automatización nivel 💯!"**
+
+---
+
+**Created:** 2025-11-06  
+**Version:** 1.0.0  
+**Author:** Carlos Merlos + IA 🤝

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

@@ -0,0 +1,38 @@
+describe('AST Intelligence Automation MCP', () => {
+  describe('module structure', () => {
+    it('should exist as a file', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const filePath = path.join(__dirname, '../ast-intelligence-automation.js');
+      expect(fs.existsSync(filePath)).toBe(true);
+    });
+
+    it('should be valid JavaScript', () => {
+      expect(() => {
+        require.resolve('../ast-intelligence-automation.js');
+      }).not.toThrow();
+    });
+  });
+
+  describe('constants', () => {
+    it('should define MCP version', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const content = fs.readFileSync(
+        path.join(__dirname, '../ast-intelligence-automation.js'),
+        'utf-8'
+      );
+      expect(content).toContain('MCP_VERSION');
+    });
+
+    it('should define REPO_ROOT', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const content = fs.readFileSync(
+        path.join(__dirname, '../ast-intelligence-automation.js'),
+        'utf-8'
+      );
+      expect(content).toContain('REPO_ROOT');
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/mcp/__tests__/evidence-watcher.spec.js

@@ -0,0 +1,38 @@
+describe('Evidence Watcher MCP', () => {
+  describe('module structure', () => {
+    it('should exist as a file', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const filePath = path.join(__dirname, '../evidence-watcher.js');
+      expect(fs.existsSync(filePath)).toBe(true);
+    });
+
+    it('should be valid JavaScript', () => {
+      expect(() => {
+        require.resolve('../evidence-watcher.js');
+      }).not.toThrow();
+    });
+  });
+
+  describe('constants', () => {
+    it('should define MCP version', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const content = fs.readFileSync(
+        path.join(__dirname, '../evidence-watcher.js'),
+        'utf-8'
+      );
+      expect(content).toContain('MCP_VERSION');
+    });
+
+    it('should define MAX_EVIDENCE_AGE', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const content = fs.readFileSync(
+        path.join(__dirname, '../evidence-watcher.js'),
+        'utf-8'
+      );
+      expect(content).toContain('MAX_EVIDENCE_AGE');
+    });
+  });
+});