pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * MCP Server: AI Evidence Watcher
+ *
+ * Exposes evidence status to AI in Cursor via Model Context Protocol
+ * The AI can automatically check if evidence is stale and update it
+ */
+
+const path = require('path');
+const McpProtocolHandler = require('./services/McpProtocolHandler');
+const EvidenceService = require('./services/EvidenceService');
+const UnifiedLogger = require('../../application/services/logging/UnifiedLogger');
+
+const MCP_VERSION = '1.0.0';
+const MAX_EVIDENCE_AGE = 3 * 60 * 1000;
+
+// Initialize Logger
+const repoRoot = process.env.REPO_ROOT || process.cwd();
+const logger = new UnifiedLogger({
+    component: 'EvidenceWatcherMCP',
+    console: { enabled: false }, // MCP uses stdout/stdin, so we can't log to console
+    file: {
+        enabled: true,
+        path: path.join(repoRoot, '.audit-reports', 'mcp-evidence.log'),
+        level: 'info'
+    }
+});
+
+const evidenceService = new EvidenceService(repoRoot, logger);
+const protocolHandler = new McpProtocolHandler(process.stdin, process.stdout, logger);
+
+if (logger) logger.info('MCP_SERVER_STARTED');
+
+protocolHandler.start((message) => {
+    try {
+        const request = JSON.parse(message);
+
+        if ((typeof request.id === 'undefined' || request.id === null) && request.method?.startsWith('notifications/')) {
+            return null; // Don't respond to notifications
+        }
+
+        if (request.method === 'initialize') {
+            return protocolHandler.createInitializeResponse(request.id);
+        }
+
+        if (request.method === 'resources/list') {
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                result: {
+                    resources: [
+                        {
+                            uri: 'evidence://status',
+                            name: 'Evidence Status',
+                            description: 'Current status of .AI_EVIDENCE.json (fresh or stale)',
+                            mimeType: 'application/json'
+                        }
+                    ]
+                }
+            };
+        }
+
+        if (request.method === 'resources/read') {
+            const uri = request.params?.uri;
+            if (uri === 'evidence://status') {
+                const status = evidenceService.checkStatus();
+                return {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    result: {
+                        contents: [
+                            {
+                                uri: 'evidence://status',
+                                mimeType: 'application/json',
+                                text: JSON.stringify(status, null, 2)
+                            }
+                        ]
+                    }
+                };
+            }
+        }
+
+        if (request.method === 'tools/list') {
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                result: {
+                    tools: [
+                        {
+                            name: 'check_evidence_status',
+                            description: 'Check if .AI_EVIDENCE.json is stale (>3 minutes old)',
+                            inputSchema: {
+                                type: 'object',
+                                properties: {},
+                                required: []
+                            }
+                        }
+                    ]
+                }
+            };
+        }
+
+        if (request.method === 'tools/call') {
+            const toolName = request.params?.name;
+            if (toolName === 'check_evidence_status') {
+                const status = evidenceService.checkStatus();
+                return {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    result: {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(status, null, 2)
+                            }
+                        ]
+                    }
+                };
+            }
+        }
+
+        return protocolHandler.createErrorResponse(request.id, -32601, `Method not found: ${request.method}`);
+
+    } catch (err) {
+        if (logger) logger.error('MCP_PARSE_ERROR', { error: err.message });
+        return protocolHandler.createErrorResponse(null, -32700, `Parse error: ${err.message}`);
+    }
+});

package/scripts/hooks-system/infrastructure/mcp/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "mcp-ai-evidence-watcher",
+    "version": "1.0.0",
+    "description": "MCP server to monitor .AI_EVIDENCE.json freshness for AI automation",
+    "type": "commonjs",
+    "bin": {
+        "mcp-ai-evidence-watcher": "./evidence-watcher.js"
+    },
+    "keywords": [
+        "mcp",
+        "cursor",
+        "ai",
+        "evidence"
+    ],
+    "author": "Carlos Merlos",
+    "license": "MIT"
+}

package/scripts/hooks-system/infrastructure/mcp/services/EvidenceService.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class EvidenceService {
+    constructor(repoRoot, logger) {
+        this.repoRoot = repoRoot || process.env.REPO_ROOT || process.cwd();
+        this.evidenceFile = path.join(this.repoRoot, '.AI_EVIDENCE.json');
+        this.maxEvidenceAge = 180; // 3 minutes
+        this.logger = logger;
+    }
+
+    getCurrentBranch() {
+        try {
+            const branch = execSync('git branch --show-current', {
+                cwd: this.repoRoot,
+                encoding: 'utf-8'
+            }).trim();
+            return branch || 'unknown';
+        } catch (err) {
+            if (this.logger) this.logger.warn('GIT_BRANCH_ERROR', { error: err.message });
+            return 'unknown';
+        }
+    }
+
+    checkStatus() {
+        try {
+            if (!fs.existsSync(this.evidenceFile)) {
+                return {
+                    status: 'missing',
+                    message: '.AI_EVIDENCE.json not found',
+                    action: `Run: ai-start ${this.getCurrentBranch()}`,
+                    age: null,
+                    isStale: true
+                };
+            }
+
+            const evidence = JSON.parse(fs.readFileSync(this.evidenceFile, 'utf-8'));
+            const timestamp = evidence.timestamp;
+
+            if (!timestamp) {
+                return {
+                    status: 'invalid',
+                    message: 'No timestamp in .AI_EVIDENCE.json',
+                    action: `Run: ai-start ${this.getCurrentBranch()}`,
+                    age: null,
+                    isStale: true
+                };
+            }
+
+            const evidenceTime = new Date(timestamp).getTime();
+            const currentTime = Date.now();
+            const ageSeconds = Math.floor((currentTime - evidenceTime) / 1000);
+            const isStale = ageSeconds > this.maxEvidenceAge;
+
+            const result = {
+                status: isStale ? 'stale' : 'fresh',
+                message: isStale
+                    ? `Evidence is STALE (${ageSeconds}s old, max ${this.maxEvidenceAge}s)`
+                    : `Evidence is fresh (${ageSeconds}s old)`,
+                action: isStale ? `Run: ai-start ${this.getCurrentBranch()}` : null,
+                age: ageSeconds,
+                isStale: isStale,
+                timestamp: timestamp,
+                session: evidence.session || 'unknown',
+                currentBranch: this.getCurrentBranch()
+            };
+
+            if (this.logger && this.logger.debug) {
+                this.logger.debug('EVIDENCE_CHECKED', { status: result.status, age: result.age });
+            }
+
+            return result;
+        } catch (err) {
+            if (this.logger) this.logger.error('EVIDENCE_CHECK_ERROR', { error: err.message });
+            return {
+                status: 'error',
+                message: `Error checking evidence: ${err.message}`,
+                action: `Run: ai-start ${this.getCurrentBranch()}`,
+                age: null,
+                isStale: true
+            };
+        }
+    }
+}
+
+module.exports = EvidenceService;

package/scripts/hooks-system/infrastructure/mcp/services/McpProtocolHandler.js

@@ -0,0 +1,166 @@
+const MCP_VERSION = '2024-11-05';
+
+class McpProtocolHandler {
+    constructor(inputStream, outputStream, logger) {
+        this.inputStream = inputStream;
+        this.outputStream = outputStream;
+        this.logger = logger;
+        this.buffer = '';
+    }
+
+    start(messageHandler) {
+        this.inputStream.setEncoding('utf8');
+
+        this.inputStream.on('data', (chunk) => {
+            void this._handleChunk(chunk, messageHandler);
+        });
+
+        this.inputStream.on('end', () => {
+            if (this.logger) this.logger.info('MCP_STDIN_CLOSED');
+            process.exit(0);
+        });
+
+        this.inputStream.on('error', (err) => {
+            if (this.logger) this.logger.error('MCP_STDIN_ERROR', { error: err.message });
+            process.exit(1);
+        });
+    }
+
+    async _handleChunk(chunk, messageHandler) {
+        this.buffer += chunk.toString();
+        const messages = this.extractMessages();
+
+        for (const message of messages) {
+            const payload = message?.body || '';
+            if (!payload.trim()) {
+                continue;
+            }
+
+            if (this.logger) {
+                this.logger.debug('MCP_RECEIVED', { payload: payload.substring(0, 100) });
+            }
+
+            try {
+                const response = await Promise.resolve(messageHandler(payload));
+                if (response === null || typeof response === 'undefined') {
+                    continue;
+                }
+
+                const responseStr = JSON.stringify(response);
+                if (this.logger) {
+                    this.logger.debug('MCP_SENDING', { response: responseStr.substring(0, 100) });
+                }
+                this.writeResponse(response, Boolean(message?.framed), message?.delimiter);
+            } catch (error) {
+                if (this.logger) {
+                    this.logger.error('MCP_MESSAGE_HANDLER_ERROR', { error: error.message });
+                }
+                const errResponse = this.createErrorResponse(null, -32603, `Internal error: ${error.message}`);
+                this.writeResponse(errResponse, Boolean(message?.framed), message?.delimiter);
+            }
+        }
+    }
+
+    extractMessages() {
+        const messages = [];
+
+        while (this.buffer.length > 0) {
+            const crlfHeaderEnd = this.buffer.indexOf('\r\n\r\n');
+            const lfHeaderEnd = crlfHeaderEnd === -1 ? this.buffer.indexOf('\n\n') : -1;
+            const headerEnd = crlfHeaderEnd !== -1 ? crlfHeaderEnd : lfHeaderEnd;
+            const headerDelimiter = crlfHeaderEnd !== -1 ? '\r\n\r\n' : (lfHeaderEnd !== -1 ? '\n\n' : null);
+
+            if (headerDelimiter) {
+                const headerBlock = this.buffer.slice(0, headerEnd);
+                const contentLengthLine = headerBlock
+                    .split(/\r?\n/)
+                    .find(line => /^content-length:/i.test(line));
+
+                if (contentLengthLine) {
+                    const match = contentLengthLine.match(/content-length:\s*(\d+)/i);
+                    const contentLength = match ? Number(match[1]) : NaN;
+                    if (!Number.isFinite(contentLength) || contentLength < 0) {
+                        this.buffer = this.buffer.slice(headerEnd + headerDelimiter.length);
+                        continue;
+                    }
+
+                    const bodyStart = headerEnd + headerDelimiter.length;
+                    if (this.buffer.length < bodyStart + contentLength) {
+                        break;
+                    }
+
+                    const body = this.buffer.slice(bodyStart, bodyStart + contentLength);
+                    messages.push({ body, framed: true, delimiter: headerDelimiter });
+                    this.buffer = this.buffer.slice(bodyStart + contentLength);
+                    continue;
+                }
+            }
+
+            const nl = this.buffer.indexOf('\n');
+            if (nl === -1) {
+                break;
+            }
+
+            const line = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (line) {
+                messages.push({ body: line, framed: false });
+            }
+        }
+
+        return messages;
+    }
+
+    writeResponse(response, framed, delimiter) {
+        const responseStr = JSON.stringify(response);
+
+        if (framed) {
+            const len = Buffer.byteLength(responseStr, 'utf8');
+            const sep = delimiter === '\n\n' ? '\n\n' : '\r\n\r\n';
+            this.outputStream.write(`Content-Length: ${len}${sep}${responseStr}`);
+        } else {
+            this.outputStream.write(responseStr + '\n');
+        }
+
+        if (typeof this.outputStream.flush === 'function') {
+            this.outputStream.flush();
+        }
+    }
+
+    createInitializeResponse(id) {
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            result: {
+                protocolVersion: MCP_VERSION,
+                capabilities: {
+                    resources: {
+                        subscribe: false,
+                        listChanged: false
+                    },
+                    tools: {
+                        listChanged: false
+                    }
+                },
+                serverInfo: {
+                    name: 'ai-evidence-watcher',
+                    version: '1.0.0'
+                }
+            }
+        };
+    }
+
+    createErrorResponse(id, code, message) {
+        return {
+            jsonrpc: '2.0',
+            id: id,
+            error: {
+                code,
+                message
+            }
+        };
+    }
+}
+
+module.exports = McpProtocolHandler;
+

package/scripts/hooks-system/infrastructure/orchestration/__tests__/intelligent-audit.spec.js

@@ -0,0 +1,11 @@
+describe('intelligent-audit', () => {
+  it('should export module', () => {
+    const mod = require('../intelligent-audit');
+    expect(mod).toBeDefined();
+  });
+
+  it('should have runIntelligentAudit function', () => {
+    const mod = require('../intelligent-audit');
+    expect(typeof mod.runIntelligentAudit).toBe('function');
+  });
+});