pumuki-ast-hooks 5.3.1

package/hooks/pre-tool-use-guard.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+interface ToolInput {
+    tool_name: string;
+    tool_input: {
+        file_path?: string;
+        target_file?: string;
+        contents?: string;
+        new_string?: string;
+    };
+}
+
+interface FileTriggers {
+    pathPatterns?: string[];
+    pathExclusions?: string[];
+    contentPatterns?: string[];
+}
+
+interface SkipConditions {
+    sessionSkillUsed?: boolean;
+    fileMarkers?: string[];
+    envOverride?: string;
+}
+
+interface SkillRule {
+    type: 'guardrail' | 'domain';
+    enforcement: 'block' | 'suggest' | 'warn';
+    fileTriggers?: FileTriggers;
+    blockMessage?: string;
+    skipConditions?: SkipConditions;
+}
+
+interface SkillRules {
+    version: string;
+    skills: Record<string, SkillRule>;
+}
+
+async function readStdin(): Promise<string> {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+    });
+}
+
+function matchesPathPattern(filePath: string, patterns: string[]): boolean {
+    for (const pattern of patterns) {
+        const regexPattern = pattern
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        const regex = new RegExp(`^${regexPattern}$`);
+        if (regex.test(filePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function shouldSkip(skipConditions?: SkipConditions, filePath?: string): boolean {
+    if (!skipConditions) {
+        return false;
+    }
+
+    if (skipConditions.envOverride && process.env[skipConditions.envOverride]) {
+        return true;
+    }
+
+    if (skipConditions.fileMarkers && filePath && existsSync(filePath)) {
+        const content = readFileSync(filePath, 'utf8');
+        for (const marker of skipConditions.fileMarkers) {
+            if (content.includes(marker)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+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 filePath = input.tool_input?.file_path || input.tool_input?.target_file;
+        if (!filePath) {
+            process.exit(0);
+        }
+
+        const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        const { getSkillRulesPath } = await import('./getSkillRulesPath.js');
+        const rulesPath = getSkillRulesPath(projectDir);
+
+        if (!rulesPath || !existsSync(rulesPath)) {
+            process.exit(0);
+        }
+
+        const rulesContent = readFileSync(rulesPath, 'utf8');
+        const rules: SkillRules = JSON.parse(rulesContent);
+
+        if (!rules.skills) {
+            process.exit(0);
+        }
+
+        for (const [skillName, skill] of Object.entries(rules.skills)) {
+            const rule = skill as SkillRule;
+            if (rule.enforcement !== 'block') {
+                continue;
+            }
+            if (!rule.fileTriggers) {
+                continue;
+            }
+
+            if (rule.fileTriggers.pathPatterns) {
+                if (!matchesPathPattern(filePath, rule.fileTriggers.pathPatterns)) {
+                    continue;
+                }
+            }
+
+            if (rule.fileTriggers.pathExclusions) {
+                if (matchesPathPattern(filePath, rule.fileTriggers.pathExclusions)) {
+                    continue;
+                }
+            }
+
+            if (shouldSkip(rule.skipConditions, filePath)) {
+                continue;
+            }
+
+            const message = rule.blockMessage?.replace('{file_path}', filePath) ||
+                `⚠️ BLOCKED - ${skillName} guardrail triggered for ${filePath}`;
+            process.stderr.write(`${message}\n`);
+            process.exit(2);
+        }
+
+        process.exit(0);
+    } catch (err) {
+        process.stderr.write(`Error in pre-tool-use-guard hook: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(0);
+    }
+}
+
+main().catch(() => {
+    process.exit(0);
+});

package/hooks/skill-activation-prompt.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+HOOKS_DIR="$PROJECT_DIR/.ast-intelligence/hooks"
+
+cd "$HOOKS_DIR"
+cat | npx tsx skill-activation-prompt.ts

package/hooks/skill-activation-prompt.ts

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { sendMacOSNotification } from './notify-macos.ts';
+import { detectPlatformFromFiles, detectPlatformFromBranch } from './git-status-monitor.ts';
+
+interface HookInput {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    permission_mode: string;
+    prompt: string;
+}
+
+interface PromptTriggers {
+    keywords?: string[];
+    intentPatterns?: string[];
+}
+
+interface SkillRule {
+    type: 'guardrail' | 'domain';
+    enforcement: 'block' | 'suggest' | 'warn';
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    promptTriggers?: PromptTriggers;
+}
+
+interface SkillRules {
+    version: string;
+    skills: Record<string, SkillRule>;
+}
+
+interface MatchedSkill {
+    name: string;
+    matchType: 'keyword' | 'intent';
+    config: SkillRule;
+}
+
+function logDebug(message: string, error?: unknown): void {
+    const enabled = process.env.DEBUG === '1'
+        || process.env.DEBUG === 'true'
+        || process.env.NODE_ENV === 'development';
+    if (!enabled) {
+        return;
+    }
+    if (error instanceof Error) {
+        process.stderr.write(`[skill-activation-prompt] ${message}: ${error.message}\n`);
+        return;
+    }
+    if (error) {
+        process.stderr.write(`[skill-activation-prompt] ${message}: ${String(error)}\n`);
+        return;
+    }
+    process.stderr.write(`[skill-activation-prompt] ${message}\n`);
+}
+
+async function readStdin(): Promise<string> {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+    });
+}
+
+function detectPlatformsFromSkills(matchedSkills: MatchedSkill[]): string {
+    const platforms: string[] = [];
+    for (const skill of matchedSkills) {
+        if (skill.name === 'backend-guidelines') platforms.push('backend');
+        else if (skill.name === 'frontend-guidelines') platforms.push('frontend');
+        else if (skill.name === 'ios-guidelines') platforms.push('ios');
+        else if (skill.name === 'android-guidelines') platforms.push('android');
+    }
+    return platforms.length > 0 ? platforms.join(',') : 'frontend,backend,ios,android';
+}
+
+function updateEvidenceAuto(projectDir: string, platforms: string): void {
+    try {
+        const updateScript = join(projectDir, 'scripts', 'hooks-system', 'bin', 'update-evidence.sh');
+        if (!existsSync(updateScript)) {
+            return;
+        }
+        const sessionId = `auto-evidence-${Date.now()}`;
+        execSync(`bash "${updateScript}" --auto --platforms "${platforms}"`, {
+            cwd: projectDir,
+            env: {
+                ...process.env,
+                AUTO_EVIDENCE_REASON: sessionId,
+                AUTO_EVIDENCE_TRIGGER: 'skill-activation-hook',
+                AUTO_EVIDENCE_SUMMARY: 'Auto-update executed by skill-activation-prompt hook',
+                AUTO_EVIDENCE_EXTRA: 'Evidence auto-updated after detecting relevant skills.',
+                AUTO_EVIDENCE_PLATFORM_LIST: platforms
+            },
+            stdio: 'ignore'
+        });
+
+        setTimeout(() => {
+            try {
+                sendMacOSNotification({
+                    title: '✅ Evidence Updated',
+                    subtitle: 'Auto-updated',
+                    message: `Platforms: ${platforms}`,
+                    sound: 'Ping'
+                });
+            } catch (notifyErr) {
+                logDebug('Failed to send success notification', notifyErr);
+            }
+        }, 500);
+    } catch (err) {
+        setTimeout(() => {
+            try {
+                sendMacOSNotification({
+                    title: '⚠️ Evidence Update Failed',
+                    subtitle: 'Auto-update error',
+                    message: 'Evidence may be stale',
+                    sound: 'Basso'
+                });
+            } catch (notifyErr) {
+                logDebug('Failed to send failure notification', notifyErr);
+            }
+        }, 700);
+    }
+}
+
+async function main() {
+    try {
+        const inputStr = await readStdin();
+        const data: HookInput = JSON.parse(inputStr);
+        const prompt = data.prompt.toLowerCase();
+
+        const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        const rulesPath = join(projectDir, '.ast-intelligence', 'skills', 'skill-rules.json');
+
+        if (!existsSync(rulesPath)) {
+            process.exit(0);
+        }
+        const rules: SkillRules = JSON.parse(readFileSync(rulesPath, 'utf-8'));
+
+        const matchedSkills: MatchedSkill[] = [];
+
+        for (const [skillName, config] of Object.entries(rules.skills)) {
+            const triggers = config.promptTriggers;
+            if (!triggers) {
+                continue;
+            }
+
+            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 => {
+                    const regex = new RegExp(pattern, 'i');
+                    return regex.test(prompt);
+                });
+                if (intentMatch) {
+                    matchedSkills.push({ name: skillName, matchType: 'intent', config });
+                }
+            }
+        }
+
+        const originalPrompt = data.prompt;
+
+        if (originalPrompt.trim().startsWith('@')) {
+            process.exit(0);
+            return;
+        }
+
+        if (matchedSkills.length === 0) {
+            const isGenericPrompt = /^(continue|ok|yes|go|next|proceed|forward|do it|do|run|let's go|perfect|fine|great|sounds good|ok buddy)$/i.test(originalPrompt.trim());
+
+            if (isGenericPrompt) {
+                const platformsFromFiles = detectPlatformFromFiles(projectDir);
+                const gitBranch = (() => {
+                    try {
+                        return execSync('git rev-parse --abbrev-ref HEAD', { cwd: projectDir, encoding: 'utf8' }).trim();
+                    } catch (error) {
+                        logDebug('Failed to detect git branch', error);
+                        return '';
+                    }
+                })();
+                const platformsFromBranch = gitBranch ? detectPlatformFromBranch(gitBranch) : [];
+                const contextPlatforms = [...new Set([...platformsFromFiles, ...platformsFromBranch])];
+
+                const contextSkills: MatchedSkill[] = [];
+                for (const platform of contextPlatforms) {
+                    let skillName = '';
+                    if (platform === 'backend') skillName = 'backend-guidelines';
+                    else if (platform === 'frontend') skillName = 'frontend-guidelines';
+                    else if (platform === 'ios') skillName = 'ios-guidelines';
+                    else if (platform === 'android') skillName = 'android-guidelines';
+
+                    if (skillName && rules.skills[skillName]) {
+                        contextSkills.push({
+                            name: skillName,
+                            matchType: 'keyword',
+                            config: rules.skills[skillName]
+                        });
+                    }
+                }
+
+                if (contextSkills.length > 0) {
+                    matchedSkills.push(...contextSkills);
+                }
+            }
+        }
+
+        if (matchedSkills.length > 0) {
+            const platforms = detectPlatformsFromSkills(matchedSkills);
+            updateEvidenceAuto(projectDir, platforms);
+
+            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');
+
+            const skillsToAutoLoad = [...critical, ...high];
+            const skillsToSuggest = [...medium, ...low];
+
+            if (skillsToAutoLoad.length > 0) {
+                const skillNames = skillsToAutoLoad.map(s => `@${s.name}`).join(' ');
+                const modifiedPrompt = `${skillNames} ${originalPrompt}`;
+
+                setTimeout(() => {
+                    try {
+                        sendMacOSNotification({
+                            title: '🎯 Skills Auto-Loaded',
+                            subtitle: `${skillsToAutoLoad.length} skill(s) detected`,
+                            message: `Auto-loaded: ${skillsToAutoLoad.map(s => s.name).join(', ')}`
+                        });
+                    } catch (err) {
+                        logDebug('Failed to send skills auto-loaded notification', err);
+                    }
+                }, 100);
+
+                process.stdout.write(`${modifiedPrompt}\n`);
+                process.exit(0);
+                return;
+            }
+
+            let output = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+            output += '🎯 SKILL ACTIVATION CHECK\n';
+            output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
+
+            if (critical.length > 0) {
+                output += '⚠️ CRITICAL SKILLS (AUTO-LOADED):\n';
+                critical.forEach(s => output += `  → ${s.name}\n`);
+                output += '\n';
+            }
+
+            if (high.length > 0) {
+                output += '📚 RECOMMENDED SKILLS (AUTO-LOADED):\n';
+                high.forEach(s => output += `  → ${s.name}\n`);
+                output += '\n';
+            }
+
+            if (skillsToSuggest.length > 0) {
+                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';
+                }
+
+                output += 'ACTION: Use Skill tool BEFORE responding\n';
+
+                setTimeout(() => {
+                    try {
+                        sendMacOSNotification({
+                            title: '💡 Skills Suggested',
+                            subtitle: `${skillsToSuggest.length} skill(s) available`,
+                            message: `Consider using: ${skillsToSuggest.map(s => s.name).join(', ')}`,
+                            sound: 'Glass'
+                        });
+                    } catch (err) {
+                        logDebug('Failed to send skills suggested notification', err);
+                    }
+                }, 300);
+            } else {
+                output += '✅ Skills auto-loaded - Continue with your prompt\n';
+            }
+            output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
+
+            process.stdout.write(`${output}\n`);
+        }
+
+        process.exit(0);
+    } catch (err) {
+        process.stderr.write(`Error in skill-activation-prompt hook: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    process.stderr.write(`Uncaught error: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/index.js

@@ -0,0 +1,49 @@
+/**
+ * @pumuki/ast-intelligence-hooks
+ *
+ * Enterprise-grade AST Intelligence System
+ * Multi-platform support: iOS, Android, Backend, Frontend
+ * Architecture enforcement: Feature-First + DDD + Clean Architecture
+ *
+ * @version 3.1.0
+ * @license MIT
+ */
+
+const { runASTIntelligence } = require('./scripts/hooks-system/infrastructure/ast/ast-intelligence');
+const { Finding } = require('./scripts/hooks-system/domain/entities/Finding');
+const { AuditResult } = require('./scripts/hooks-system/domain/entities/AuditResult');
+const { CommitBlockingRules } = require('./scripts/hooks-system/domain/rules/CommitBlockingRules');
+
+const { AnalyzeCodebaseUseCase } = require('./scripts/hooks-system/application/use-cases/AnalyzeCodebaseUseCase');
+const { AnalyzeStagedFilesUseCase } = require('./scripts/hooks-system/application/use-cases/AnalyzeStagedFilesUseCase');
+const { GenerateAuditReportUseCase } = require('./scripts/hooks-system/application/use-cases/GenerateAuditReportUseCase');
+const { BlockCommitUseCase } = require('./scripts/hooks-system/application/use-cases/BlockCommitUseCase');
+
+const { runBackendIntelligence } = require('./scripts/hooks-system/infrastructure/ast/backend/ast-backend');
+const { runFrontendIntelligence } = require('./scripts/hooks-system/infrastructure/ast/frontend/ast-frontend');
+const { runIOSIntelligence } = require('./scripts/hooks-system/infrastructure/ast/ios/ast-ios');
+const { runAndroidIntelligence } = require('./scripts/hooks-system/infrastructure/ast/android/ast-android');
+const { runCommonIntelligence } = require('./scripts/hooks-system/infrastructure/ast/common/ast-common');
+
+module.exports = {
+  runASTIntelligence,
+
+  Finding,
+  AuditResult,
+  CommitBlockingRules,
+
+  AnalyzeCodebaseUseCase,
+  AnalyzeStagedFilesUseCase,
+  GenerateAuditReportUseCase,
+  BlockCommitUseCase,
+
+  runBackendIntelligence,
+  runFrontendIntelligence,
+  runIOSIntelligence,
+  runAndroidIntelligence,
+  runCommonIntelligence,
+
+  version: '3.1.0',
+  platforms: ['ios', 'android', 'backend', 'frontend'],
+  totalRules: 798
+};

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "pumuki-ast-hooks",
+  "version": "5.3.1",
+  "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
+  "main": "index.js",
+  "bin": {
+    "pumuki-ast-hooks": "./bin/pumuki-mcp-server.js",
+    "audit": "./bin/audit",
+    "ast-hooks": "./bin/cli.js",
+    "ast-install": "./bin/install.js",
+    "ast-violations": "./bin/violations-api.js",
+    "ast-check-version": "./bin/check-version.js",
+    "ai-commit": "./bin/ai-commit.sh",
+    "hook-run-orchestrator": "./bin/run-orchestrator.js",
+    "hook-watch": "./bin/watch-hooks.js",
+    "hook-status": "./bin/hook-status.js",
+    "hook-predict": "./bin/predictive-hooks.js",
+    "hook-playbook": "./bin/run-playbook.js",
+    "hook-doc-drift": "./bin/check-doc-drift.js",
+    "hook-plan-review": "./bin/plan-review.js"
+  },
+  "scripts": {
+    "install-hooks": "npx ast-install",
+    "check-version": "node bin/check-version.js",
+    "audit": "node bin/ast",
+    "ast": "node bin/ast",
+    "audit-library": "node bin/audit-library.js",
+    "gitflow": "bash bin/gitflow check",
+    "gitflow:status": "bash bin/gitflow status",
+    "gitflow:workflow": "bash bin/gitflow workflow",
+    "gitflow:reset": "bash bin/gitflow reset",
+    "violations": "node bin/violations",
+    "violations:list": "node bin/violations list",
+    "violations:show": "node bin/violations show",
+    "violations:summary": "node bin/violations summary",
+    "violations:top": "node bin/violations top",
+    "violations:demo": "bash bin/demo-violations",
+    "test": "jest --runInBand",
+    "lint": "npm run lint:hooks",
+    "lint:hooks": "eslint \"scripts/hooks-system/application/**/*.js\" \"bin/**/*.js\"",
+    "build:ts": "tsc --noEmit",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "ast",
+    "code-quality",
+    "static-analysis",
+    "ios",
+    "android",
+    "backend",
+    "frontend",
+    "clean-architecture",
+    "ddd",
+    "feature-first",
+    "git-hooks",
+    "pre-commit",
+    "typescript",
+    "swift",
+    "kotlin",
+    "react",
+    "nextjs",
+    "nestjs"
+  ],
+  "author": {
+    "name": "Juan Carlos Merlos Albarracín",
+    "email": "freelancemerlos@gmail.com",
+    "organization": "Pumuki Team"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/carlos/ast-intelligence-hooks.git"
+  },
+  "bugs": {
+    "url": "https://github.com/carlos/ast-intelligence-hooks/issues"
+  },
+  "homepage": "https://github.com/carlos/ast-intelligence-hooks#readme",
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  },
+  "dependencies": {
+    "glob": "^10.5.0",
+    "ts-morph": "^21.0.0"
+  },
+  "devDependencies": {
+    "@pumuki/ast-intelligence-hooks": "file:pumuki-ast-intelligence-hooks-5.3.1.tgz",
+    "@types/node": "^20.10.0",
+    "eslint": "^9.12.0",
+    "jest": "^30.2.0",
+    "typescript": "^5.3.0"
+  },
+  "files": [
+    "bin/",
+    "scripts/hooks-system/",
+    "presentation/",
+    "skills/",
+    "hooks/",
+    "docs/",
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./ast": "./scripts/hooks-system/infrastructure/ast/ast-intelligence.js",
+    "./domain": "./scripts/hooks-system/domain/index.js",
+    "./application": "./scripts/hooks-system/application/index.js",
+    "./config": "./config/index.js",
+    "./skills": "./skills/skill-rules.json",
+    "./hooks": "./hooks/index.js"
+  }
+}

package/presentation/cli/audit.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Entry point for the audit hook system
+# This script acts as the main CLI interface
+
+set -euo pipefail
+
+# Get the hooks-system directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Robustly find HOOKS_SYSTEM_DIR (works for both local development and node_modules installation)
+if [[ "$SCRIPT_DIR" == *"/node_modules//ast-intelligence-hooks/presentation/cli"* ]]; then
+  HOOKS_SYSTEM_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+else
+  HOOKS_SYSTEM_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+fi
+INFRASTRUCTURE_DIR="$HOOKS_SYSTEM_DIR/infrastructure"
+
+# If a mode was provided, set AUDIT_OPTION before sourcing the orchestrator
+MODE="${1:-}"
+if [[ -n "$MODE" ]]; then
+  export AUDIT_OPTION="$MODE"
+fi
+
+# Source the orchestrator
+source "$INFRASTRUCTURE_DIR/shell/orchestrators/audit-orchestrator.sh"