pumuki-ast-hooks 5.3.1

package/hooks/getSkillRulesPath.ts

@@ -0,0 +1,52 @@
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export function getSkillRulesPath(projectDir: string): string | null {
+    const libraryRoot = join(__dirname, '..');
+    const librarySkillsPath = join(libraryRoot, 'skills', 'skill-rules.json');
+
+    const nodeModulesPath = join(projectDir, 'node_modules', '@carlos', 'ast-intelligence-hooks', 'skills', 'skill-rules.json');
+
+    const claudePath = join(projectDir, '.ast-intelligence', 'skills', 'skill-rules.json');
+
+    if (existsSync(librarySkillsPath)) {
+        return librarySkillsPath;
+    }
+
+    if (existsSync(nodeModulesPath)) {
+        return nodeModulesPath;
+    }
+
+    if (existsSync(claudePath)) {
+        return claudePath;
+    }
+
+    return null;
+}
+
+export function getSkillPath(projectDir: string, skillName: string): string | null {
+    const libraryRoot = join(__dirname, '..');
+    const librarySkillPath = join(libraryRoot, 'skills', skillName, 'SKILL.md');
+
+    const nodeModulesPath = join(projectDir, 'node_modules', '@carlos', 'ast-intelligence-hooks', 'skills', skillName, 'SKILL.md');
+
+    const claudePath = join(projectDir, '.ast-intelligence', 'skills', skillName, 'SKILL.md');
+
+    if (existsSync(librarySkillPath)) {
+        return librarySkillPath;
+    }
+
+    if (existsSync(nodeModulesPath)) {
+        return nodeModulesPath;
+    }
+
+    if (existsSync(claudePath)) {
+        return claudePath;
+    }
+
+    return null;
+}

package/hooks/git-status-monitor.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { sendMacOSNotification } from './notify-macos.ts';
+
+interface GitStatus {
+    branch: string;
+    stagedFiles: number;
+    unstagedFiles: number;
+    untrackedFiles: number;
+    hasUncommittedChanges: boolean;
+}
+
+function getGitStatus(projectDir: string): GitStatus | null {
+    try {
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: projectDir, encoding: 'utf8' }).trim();
+        const statusOutput = execSync('git status --porcelain', { cwd: projectDir, encoding: 'utf8' });
+
+        const lines = statusOutput.trim().split('\n').filter(line => line.length > 0);
+        let stagedFiles = 0;
+        let unstagedFiles = 0;
+        let untrackedFiles = 0;
+
+        for (const line of lines) {
+            const status = line.substring(0, 2);
+            if (status === '??') {
+                untrackedFiles++;
+            } else if (status[0] !== ' ' && status[0] !== '?') {
+                stagedFiles++;
+            }
+            if (status[1] !== ' ' && status[1] !== '?') {
+                unstagedFiles++;
+            }
+        }
+
+        return {
+            branch,
+            stagedFiles,
+            unstagedFiles,
+            untrackedFiles,
+            hasUncommittedChanges: lines.length > 0
+        };
+    } catch (err) {
+        return null;
+    }
+}
+
+function detectPlatformFromFiles(projectDir: string): string[] {
+    const platforms: string[] = [];
+
+    try {
+        const cacheDir = join(projectDir, '.ast-intelligence', 'tsc-cache');
+        const sessionDirs = execSync(`find "${cacheDir}" -type d -maxdepth 1 2>/dev/null | head -5`, { encoding: 'utf8' }).trim().split('\n');
+
+        const recentFiles: string[] = [];
+        for (const sessionDir of sessionDirs) {
+            if (!sessionDir || !existsSync(sessionDir)) continue;
+            const logFile = join(sessionDir, 'edited-files.log');
+            if (existsSync(logFile)) {
+                const content = readFileSync(logFile, 'utf8');
+                const lines = content.trim().split('\n').filter(l => l.length > 0);
+                recentFiles.push(...lines.slice(-20).map(l => l.split(':')[1]).filter(Boolean));
+            }
+        }
+
+        for (const file of recentFiles) {
+            if (file.includes('apps/backend') || file.includes('/backend/') || file.match(/\.(ts|js)$/) && file.includes('src/')) {
+                if (!platforms.includes('backend')) platforms.push('backend');
+            }
+            if (file.includes('apps/admin-dashboard') || file.includes('apps/web-app') || file.match(/\.(tsx|jsx)$/)) {
+                if (!platforms.includes('frontend')) platforms.push('frontend');
+            }
+            if (file.match(/\.swift$/) || file.includes('apps/ios') || file.includes('/ios/')) {
+                if (!platforms.includes('ios')) platforms.push('ios');
+            }
+            if (file.match(/\.kt$/) || file.includes('apps/android') || file.includes('/android/')) {
+                if (!platforms.includes('android')) platforms.push('android');
+            }
+        }
+    } catch (err) {
+    }
+
+    return platforms.length > 0 ? platforms : ['frontend', 'backend', 'ios', 'android'];
+}
+
+function detectPlatformFromBranch(branch: string): string[] {
+    const platforms: string[] = [];
+    const branchLower = branch.toLowerCase();
+
+    if (branchLower.includes('backend') || branchLower.includes('api') || branchLower.includes('server')) {
+        platforms.push('backend');
+    }
+    if (branchLower.includes('frontend') || branchLower.includes('web') || branchLower.includes('admin')) {
+        platforms.push('frontend');
+    }
+    if (branchLower.includes('ios') || branchLower.includes('swift') || branchLower.includes('apple')) {
+        platforms.push('ios');
+    }
+    if (branchLower.includes('android') || branchLower.includes('kotlin')) {
+        platforms.push('android');
+    }
+
+    return platforms;
+}
+
+async function main() {
+    try {
+        const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+        const gitStatus = getGitStatus(projectDir);
+        if (!gitStatus) {
+            process.exit(0);
+        }
+
+        const totalChanges = gitStatus.stagedFiles + gitStatus.unstagedFiles + gitStatus.untrackedFiles;
+
+        if (totalChanges === 0) {
+            process.exit(0);
+        }
+
+        const platformsFromFiles = detectPlatformFromFiles(projectDir);
+        const platformsFromBranch = detectPlatformFromBranch(gitStatus.branch);
+        const detectedPlatforms = [...new Set([...platformsFromFiles, ...platformsFromBranch])];
+
+        const platformInfo = detectedPlatforms.length < 4 ? ` (${detectedPlatforms.join(', ')})` : '';
+
+        if (gitStatus.stagedFiles > 0) {
+            try {
+                sendMacOSNotification({
+                    title: '📦 Git Status',
+                    subtitle: `${gitStatus.stagedFiles} staged`,
+                    message: `Branch: ${gitStatus.branch}${platformInfo}`,
+                    sound: 'Ping'
+                });
+            } catch (err) {
+            }
+        } else if (totalChanges > 10) {
+            try {
+                sendMacOSNotification({
+                    title: '📝 Many Unstaged Changes',
+                    subtitle: `${totalChanges} files changed`,
+                    message: `Branch: ${gitStatus.branch}${platformInfo}`,
+                    sound: 'Glass'
+                });
+            } catch (err) {
+            }
+        }
+
+        process.exit(0);
+    } catch (err) {
+        process.exit(0);
+    }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}
+
+export { getGitStatus, detectPlatformFromFiles, detectPlatformFromBranch };

package/hooks/index.js

@@ -0,0 +1,5 @@
+export { default as skillActivationPrompt } from './skill-activation-prompt.ts';
+export { default as preToolUseGuard } from './pre-tool-use-guard.ts';
+export { default as preToolUseEvidenceValidator } from './pre-tool-use-evidence-validator.ts';
+export { default as gitStatusMonitor } from './git-status-monitor.ts';
+export { sendMacOSNotification } from './notify-macos.js';

package/hooks/notify-macos.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+
+interface NotificationOptions {
+    title: string;
+    message: string;
+    subtitle?: string;
+    sound?: string;
+}
+
+export function sendMacOSNotification(options: NotificationOptions): void {
+    const { title, message, subtitle, sound = 'default' } = options;
+
+    const subtitlePart = subtitle ? `subtitle "${subtitle.replace(/"/g, '\\"')}"` : '';
+    const soundPart = sound ? `sound name "${sound}"` : '';
+
+    const script = `
+        display notification "${message.replace(/"/g, '\\"')}" \
+            with title "${title.replace(/"/g, '\\"')}" \
+            ${subtitlePart} \
+            ${soundPart}
+    `.trim();
+
+    try {
+        execSync(`osascript -e '${script}'`, { stdio: 'ignore' });
+    } catch (err) {
+    }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    if (args.length < 2) {
+        process.exit(1);
+    }
+
+    const title = args[0];
+    const message = args[1];
+    const subtitle = args[2];
+    const sound = args[3] || 'default';
+
+    sendMacOSNotification({ title, message, subtitle, sound });
+}

package/hooks/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "claude-hooks",
+  "version": "1.0.0",
+  "description": "Minimal dependencies for Claude Code hooks",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/hooks/post-tool-use-tracker.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+set -e
+
+tool_info=$(cat)
+
+tool_name=$(echo "$tool_info" | jq -r '.tool_name // empty')
+file_path=$(echo "$tool_info" | jq -r '.tool_input.file_path // .tool_input.target_file // empty')
+session_id=$(echo "$tool_info" | jq -r '.session_id // empty')
+
+if [[ ! "$tool_name" =~ ^(Edit|MultiEdit|Write)$ ]] || [[ -z "$file_path" ]]; then
+    exit 0
+fi
+
+if [[ "$file_path" =~ \.(md|markdown)$ ]]; then
+    exit 0
+fi
+
+cache_dir="$CLAUDE_PROJECT_DIR/.ast-intelligence/tsc-cache/${session_id:-default}"
+mkdir -p "$cache_dir"
+
+detect_repo() {
+    local file="$1"
+    local project_root="$CLAUDE_PROJECT_DIR"
+
+    local relative_path="${file#$project_root/}"
+
+    local repo=$(echo "$relative_path" | cut -d'/' -f1)
+
+    case "$repo" in
+        apps)
+            local app=$(echo "$relative_path" | cut -d'/' -f2)
+            case "$app" in
+                backend)
+                    echo "apps/backend"
+                    ;;
+                admin-dashboard|web-app)
+                    echo "apps/$app"
+                    ;;
+                ios)
+                    echo "apps/ios"
+                    ;;
+                android)
+                    echo "apps/android"
+                    ;;
+                *)
+                    echo "apps/$app"
+                    ;;
+            esac
+            ;;
+        frontend|client|web|app|ui)
+            echo "$repo"
+            ;;
+        backend|server|api|src|services)
+            echo "$repo"
+            ;;
+        database|prisma|migrations)
+            echo "$repo"
+            ;;
+        packages)
+            local package=$(echo "$relative_path" | cut -d'/' -f2)
+            if [[ -n "$package" ]]; then
+                echo "packages/$package"
+            else
+                echo "$repo"
+            fi
+            ;;
+        *)
+            if [[ ! "$relative_path" =~ / ]]; then
+                echo "root"
+            else
+                echo "unknown"
+            fi
+            ;;
+    esac
+}
+
+repo=$(detect_repo "$file_path")
+
+if [[ "$repo" == "unknown" ]] || [[ -z "$repo" ]]; then
+    exit 0
+fi
+
+echo "$(date +%s):$file_path:$repo" >> "$cache_dir/edited-files.log"
+
+if ! grep -q "^$repo$" "$cache_dir/affected-repos.txt" 2>/dev/null; then
+    echo "$repo" >> "$cache_dir/affected-repos.txt"
+fi
+
+exit 0

package/hooks/pre-tool-use-evidence-validator.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { sendMacOSNotification } from './notify-macos.js';
+
+interface ToolInput {
+    tool_name: string;
+    tool_input: {
+        file_path?: string;
+        target_file?: string;
+    };
+}
+
+interface Evidence {
+    timestamp?: string;
+    rules_read?: string[];
+    protocol_3_questions?: {
+        answered?: boolean;
+    };
+    ai_gate?: {
+        status?: string;
+        violations?: Violation[];
+        last_check?: string;
+    };
+}
+
+interface Violation {
+    severity?: string;
+    file?: string;
+    line?: number | string;
+    message?: string;
+    rule?: string;
+}
+
+const MAX_AGE_SECONDS = 180;
+
+function utcToEpoch(timestamp: string): number {
+    try {
+        return Math.floor(new Date(timestamp).getTime() / 1000);
+    } catch {
+        return 0;
+    }
+}
+
+function validateEvidence(evidencePath: string): { valid: boolean; error?: string } {
+    if (!existsSync(evidencePath)) {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Missing
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json not found
+  - Rule: Must update .AI_EVIDENCE.json before editing files
+
+📋 REQUIRED ACTION:
+1. Write a prompt (evidence auto-updates)
+2. Or run: scripts/hooks-system/bin/update-evidence.sh
+3. Then retry this edit
+
+Reason: .AI_EVIDENCE.json tracks protocol compliance (rules read, 3 questions answered)
+This is enforced by pre-commit hooks and PreToolUse validation`
+        };
+    }
+
+    let evidence: Evidence;
+    try {
+        const content = readFileSync(evidencePath, 'utf8');
+        evidence = JSON.parse(content) as Evidence;
+    } catch {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Invalid JSON
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json contains invalid JSON
+  - Rule: Must have valid JSON structure
+
+📋 REQUIRED ACTION:
+1. Fix JSON syntax errors in .AI_EVIDENCE.json
+2. Or regenerate: scripts/hooks-system/bin/update-evidence.sh
+3. Then retry this edit`
+        };
+    }
+
+    const timestamp = evidence.timestamp;
+    if (!timestamp || typeof timestamp !== 'string') {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Missing Timestamp
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json missing timestamp field
+  - Rule: Must have valid timestamp
+
+📋 REQUIRED ACTION:
+1. Write a prompt (evidence auto-updates)
+2. Or regenerate: scripts/hooks-system/bin/update-evidence.sh`
+        };
+    }
+
+    const evidenceEpoch = utcToEpoch(timestamp);
+    if (evidenceEpoch === 0) {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Invalid Timestamp Format
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json timestamp cannot be parsed
+  - Timestamp: ${timestamp}
+
+📋 REQUIRED ACTION:
+1. Regenerate: scripts/hooks-system/bin/update-evidence.sh`
+        };
+    }
+
+    const currentEpoch = Math.floor(Date.now() / 1000);
+    const ageSeconds = currentEpoch - evidenceEpoch;
+
+    if (ageSeconds > MAX_AGE_SECONDS) {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Too Old
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json timestamp is ${ageSeconds}s old (>${MAX_AGE_SECONDS}s)
+  - Rule: Must update .AI_EVIDENCE.json within ${MAX_AGE_SECONDS} seconds before editing
+
+📋 REQUIRED ACTION:
+1. Write a prompt (evidence auto-updates)
+2. Or update evidence: scripts/hooks-system/bin/update-evidence.sh
+3. Then retry this edit
+
+Reason: Stale evidence indicates protocol not followed recently
+Evidence must be fresh to ensure rules were read and questions answered`
+        };
+    }
+
+    const rulesRead = evidence.rules_read;
+    if (!rulesRead || (Array.isArray(rulesRead) && rulesRead.length === 0)) {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Missing Rules Read
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json missing rules_read field
+  - Rule: Must document which rules were read
+
+📋 REQUIRED ACTION:
+1. Write a prompt (evidence auto-updates)
+2. Or update evidence: scripts/hooks-system/bin/update-evidence.sh`
+        };
+    }
+
+    const questionsAnswered = evidence.protocol_3_questions?.answered;
+    if (questionsAnswered !== true) {
+        return {
+            valid: false,
+            error: `⚠️ BLOCKED - .AI_EVIDENCE.json Protocol Questions Not Answered
+
+📋 VIOLATION:
+  - File: .AI_EVIDENCE.json protocol_3_questions.answered is not true
+  - Rule: Must answer protocol 3 questions before editing
+
+📋 REQUIRED ACTION:
+1. Write a prompt (evidence auto-updates)
+2. Or update evidence: scripts/hooks-system/bin/update-evidence.sh`
+        };
+    }
+
+    const aiGate = evidence.ai_gate;
+    if (aiGate && aiGate.status === 'BLOCKED') {
+        const violations: Violation[] = aiGate.violations || [];
+        const criticalCount = violations.filter((v: Violation) => v.severity === 'CRITICAL').length;
+        const highCount = violations.filter((v: Violation) => v.severity === 'HIGH').length;
+        const totalBlocking = criticalCount + highCount;
+
+        const violationsList = violations
+            .slice(0, 5)
+            .map((v: Violation) => `  - ${v.file}:${v.line || '?'} [${v.severity}] ${v.message || v.rule || ''}`)
+            .join('\n');
+
+        return {
+            valid: false,
+            error: `🚫 BLOCKED - AI Gate Status: BLOCKED
+
+📋 VIOLATION:
+  - Status: ${aiGate.status}
+  - Blocking violations: ${totalBlocking} (${criticalCount} CRITICAL, ${highCount} HIGH)
+  - Last check: ${aiGate.last_check || 'unknown'}
+
+📋 VIOLATIONS:
+${violationsList}${violations.length > 5 ? `\n  ... and ${violations.length - 5} more` : ''}
+
+📋 REQUIRED ACTION:
+1. Fix all CRITICAL and HIGH violations first
+2. Run: npm run audit (or node scripts/hooks-system/infrastructure/ast/ast-intelligence.js)
+3. Verify violations are resolved
+4. Then retry this edit
+
+Reason: Code quality gate blocks edits when violations are present
+This ensures code quality standards are maintained`
+        };
+    }
+
+    return { valid: true };
+}
+
+async function readStdin(): Promise<string> {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+    });
+}
+
+async function main() {
+    try {
+        const inputStr = await readStdin();
+        const input: ToolInput = JSON.parse(inputStr);
+
+        if (input.tool_name !== 'Edit' && input.tool_name !== 'Write' && input.tool_name !== 'MultiEdit') {
+            process.exit(0);
+        }
+
+        const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        const evidencePath = join(projectDir, '.AI_EVIDENCE.json');
+
+        const validation = validateEvidence(evidencePath);
+        if (!validation.valid) {
+            try {
+                sendMacOSNotification({
+                    title: '⚠️ Edit Blocked',
+                    subtitle: 'Evidence validation failed',
+                    message: validation.error?.split('\n')[0] || 'Evidence missing or invalid',
+                    sound: 'Basso'
+                });
+            } catch (err) {
+            }
+            process.stderr.write(`${validation.error || ''}\n`);
+            process.exit(2);
+        }
+
+        process.exit(0);
+    } catch (err) {
+        process.stderr.write(`Error in pre-tool-use-evidence-validator hook: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(0);
+    }
+}
+
+main().catch(() => {
+    process.exit(0);
+});