pumuki-ast-hooks 5.5.65 → 5.6.0

package/scripts/hooks-system/infrastructure/cascade-hooks/pre-write-code-hook.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * =============================================================================
+ * 🚀 REVOLUTIONARY: Cascade Hook - pre_write_code
+ * =============================================================================
+ * 
+ * This hook is executed by Windsurf BEFORE any code is written.
+ * It uses AST Intelligence to validate the proposed code and BLOCKS
+ * the write if critical violations are detected.
+ * 
+ * Exit codes:
+ * - 0: Allow the write
+ * - 2: BLOCK the write (critical violations)
+ * - 1: Error (allow write, log error)
+ * 
+ * Author: Pumuki Team®
+ * =============================================================================
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+function getRepoRoot(filePath) {
+    if (filePath) {
+        const { execSync } = require('child_process');
+        try {
+            return execSync('git rev-parse --show-toplevel', {
+                encoding: 'utf-8',
+                cwd: path.dirname(filePath)
+            }).trim();
+        } catch (e) {
+            if (process.env.DEBUG) {
+                process.stderr.write(`[pre-write-hook] Git root lookup failed: ${e.message}\n`);
+            }
+        }
+    }
+    // Fallback: this script is in scripts/hooks-system/infrastructure/cascade-hooks/
+    return path.resolve(__dirname, '..', '..', '..', '..');
+}
+
+let REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+
+const LOG_FILE = path.join(REPO_ROOT, '.audit_tmp', 'cascade-hook.log');
+
+function log(message) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+
+    try {
+        fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+        fs.appendFileSync(LOG_FILE, logLine);
+    } catch (error) {
+        if (process.env.DEBUG) {
+            process.stderr.write(`[pre-write-hook] Log write failed: ${error.message}\n`);
+        }
+    }
+
+    if (process.env.DEBUG) {
+        process.stderr.write(logLine);
+    }
+}
+
+async function main() {
+    let inputData = '';
+
+    // Read JSON from stdin
+    for await (const chunk of process.stdin) {
+        inputData += chunk;
+    }
+
+    let hookInput;
+    try {
+        hookInput = JSON.parse(inputData);
+    } catch (error) {
+        log(`ERROR: Failed to parse hook input: ${error.message}`);
+        process.exit(1); // Error, allow write
+    }
+
+    const { agent_action_name, tool_info } = hookInput;
+
+    if (agent_action_name !== 'pre_write_code') {
+        log(`SKIP: Not a pre_write_code event: ${agent_action_name}`);
+        process.exit(0);
+    }
+
+    const filePath = tool_info?.file_path;
+    const edits = tool_info?.edits || [];
+
+    if (!filePath) {
+        log('WARN: No file_path in tool_info');
+        process.exit(0);
+    }
+
+    // Update REPO_ROOT based on the file being edited
+    REPO_ROOT = getRepoRoot(filePath);
+
+    log(`ANALYZING: ${filePath} (${edits.length} edits) [REPO: ${REPO_ROOT}]`);
+
+    // Skip test files from blocking (allow TDD flow)
+    if (/\.(spec|test)\.(js|ts|swift|kt)$/.test(filePath)) {
+        log(`ALLOW: Test file detected - TDD cycle allowed: ${filePath}`);
+        process.exit(0);
+    }
+
+    // Load AST analyzer
+    let analyzeCodeInMemory;
+    try {
+        const astCore = require(path.join(REPO_ROOT, 'scripts/hooks-system/infrastructure/ast/ast-core'));
+        analyzeCodeInMemory = astCore.analyzeCodeInMemory;
+    } catch (error) {
+        log(`ERROR: Failed to load AST analyzer: ${error.message}`);
+        process.exit(1); // Error, allow write (graceful degradation)
+    }
+
+    // Analyze each edit
+    const allViolations = [];
+
+    for (const edit of edits) {
+        const newCode = edit.new_string || '';
+
+        if (!newCode || newCode.trim().length === 0) {
+            continue;
+        }
+
+        try {
+            const analysis = analyzeCodeInMemory(newCode, filePath);
+
+            if (analysis.hasCritical) {
+                allViolations.push(...analysis.violations.filter(v => v.severity === 'CRITICAL'));
+            }
+        } catch (error) {
+            log(`WARN: AST analysis failed for edit: ${error.message}`);
+        }
+    }
+
+    if (allViolations.length > 0) {
+        const errorMessage = [
+            '',
+            '🚫 ═══════════════════════════════════════════════════════════════',
+            '🚫 AST INTELLIGENCE BLOCKED THIS WRITE',
+            '🚫 ═══════════════════════════════════════════════════════════════',
+            '',
+            `📁 File: ${filePath}`,
+            `❌ Critical Violations: ${allViolations.length}`,
+            '',
+            ...allViolations.map((v, i) => `  ${i + 1}. [${v.ruleId}] ${v.message}`),
+            '',
+            '🔧 FIX THESE VIOLATIONS BEFORE WRITING:',
+            ...allViolations.slice(0, 3).map(v => `  → ${v.message}`),
+            '',
+            '═══════════════════════════════════════════════════════════════',
+            ''
+        ].join('\n');
+
+        log(`BLOCKED: ${allViolations.length} critical violations in ${filePath}`);
+        process.stderr.write(errorMessage);
+        process.exit(2); // EXIT CODE 2 = BLOCK THE WRITE
+    }
+
+    log(`ALLOWED: No critical violations in ${filePath}`);
+    process.exit(0);
+}
+
+main().catch(error => {
+    log(`FATAL ERROR: ${error.message}`);
+    process.exit(1);
+});

package/scripts/hooks-system/infrastructure/cascade-hooks/universal-hook-adapter.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * =============================================================================
+ * 🌐 UNIVERSAL: IDE-Agnostic Hook Adapter
+ * =============================================================================
+ * 
+ * This adapter works with ANY IDE that supports hooks:
+ * - Windsurf: pre_write_code, post_write_code
+ * - Cursor: afterFileEdit
+ * - Claude Code: afterFileEdit
+ * 
+ * For IDEs without pre-write hooks, the Git pre-commit is the 100% fallback.
+ * 
+ * Author: Pumuki Team®
+ * =============================================================================
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const REPO_ROOT = (() => {
+    try {
+        const { execSync } = require('child_process');
+        return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+    } catch (error) {
+        return process.cwd();
+    }
+})();
+
+const LOG_FILE = path.join(REPO_ROOT, '.audit_tmp', 'universal-hook.log');
+
+function log(level, message) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] [${level}] ${message}\n`;
+
+    try {
+        fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+        fs.appendFileSync(LOG_FILE, logLine);
+    } catch (writeError) {
+        if (process.env.DEBUG) {
+            process.stderr.write(`[universal-hook] Log failed: ${writeError.message}\n`);
+        }
+    }
+
+    if (process.env.DEBUG || level === 'ERROR') {
+        process.stderr.write(logLine);
+    }
+}
+
+function detectIDE() {
+    if (process.env.WINDSURF_SESSION_ID) return 'windsurf';
+    if (process.env.CURSOR_SESSION_ID) return 'cursor';
+    if (process.env.CLAUDE_CODE_SESSION) return 'claude-code';
+    if (process.env.KILO_CODE_SESSION) return 'kilo-code';
+
+    const parentProcess = process.env._ || '';
+    if (parentProcess.includes('windsurf')) return 'windsurf';
+    if (parentProcess.includes('cursor')) return 'cursor';
+    if (parentProcess.includes('claude')) return 'claude-code';
+
+    return 'unknown';
+}
+
+function analyzeCode(code, filePath) {
+    try {
+        const { analyzeCodeInMemory } = require(path.join(
+            REPO_ROOT,
+            'scripts/hooks-system/infrastructure/ast/ast-core'
+        ));
+        return analyzeCodeInMemory(code, filePath);
+    } catch (loadError) {
+        log('ERROR', `AST load failed: ${loadError.message}`);
+        return { success: false, violations: [], hasCritical: false };
+    }
+}
+
+async function handleWindsurfPreWrite(hookInput) {
+    const { tool_info } = hookInput;
+    const filePath = tool_info?.file_path;
+    const edits = tool_info?.edits || [];
+
+    if (!filePath) {
+        log('WARN', 'No file_path in Windsurf hook');
+        return 0;
+    }
+
+    if (/\.(spec|test)\.(js|ts|swift|kt)$/.test(filePath)) {
+        log('INFO', `TDD: Test file allowed: ${filePath}`);
+        return 0;
+    }
+
+    for (const edit of edits) {
+        const newCode = edit.new_string || '';
+        if (!newCode.trim()) continue;
+
+        const analysis = analyzeCode(newCode, filePath);
+
+        if (analysis.hasCritical) {
+            const violations = analysis.violations.filter(v => v.severity === 'CRITICAL');
+            log('BLOCKED', `${violations.length} critical violations in ${filePath}`);
+
+            process.stderr.write(`\n🚫 AST INTELLIGENCE BLOCKED\n`);
+            process.stderr.write(`File: ${filePath}\n`);
+            violations.forEach(v => {
+                process.stderr.write(`  ❌ [${v.ruleId}] ${v.message}\n`);
+            });
+            process.stderr.write(`\n`);
+
+            return 2; // BLOCK
+        }
+    }
+
+    log('ALLOWED', `No violations in ${filePath}`);
+    return 0;
+}
+
+async function handleCursorAfterEdit(hookInput) {
+    const { tool_info } = hookInput;
+    const filePath = tool_info?.file_path;
+
+    log('INFO', `Cursor afterFileEdit: ${filePath}`);
+
+    // For Cursor, we can only log - blocking happens at Git pre-commit
+    return 0;
+}
+
+async function handleClaudeCodeAfterEdit(hookInput) {
+    const { tool_info } = hookInput;
+    const filePath = tool_info?.file_path;
+
+    log('INFO', `Claude Code afterFileEdit: ${filePath}`);
+
+    // For Claude Code, we can only log - blocking happens at Git pre-commit
+    return 0;
+}
+
+async function main() {
+    let inputData = '';
+
+    for await (const chunk of process.stdin) {
+        inputData += chunk;
+    }
+
+    if (!inputData.trim()) {
+        log('WARN', 'Empty input received');
+        process.exit(0);
+    }
+
+    let hookInput;
+    try {
+        hookInput = JSON.parse(inputData);
+    } catch (parseError) {
+        log('ERROR', `JSON parse failed: ${parseError.message}`);
+        process.exit(1);
+    }
+
+    const ide = detectIDE();
+    const eventName = hookInput.agent_action_name || hookInput.event || 'unknown';
+
+    log('INFO', `IDE: ${ide}, Event: ${eventName}`);
+
+    let exitCode = 0;
+
+    switch (eventName) {
+        case 'pre_write_code':
+            exitCode = await handleWindsurfPreWrite(hookInput);
+            break;
+        case 'afterFileEdit':
+            if (ide === 'cursor') {
+                exitCode = await handleCursorAfterEdit(hookInput);
+            } else {
+                exitCode = await handleClaudeCodeAfterEdit(hookInput);
+            }
+            break;
+        default:
+            log('INFO', `Unhandled event: ${eventName}`);
+            exitCode = 0;
+    }
+
+    process.exit(exitCode);
+}
+
+main().catch(error => {
+    log('FATAL', error.message);
+    process.exit(1);
+});