pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/bin/nightly-metrics-report.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = process.cwd();
+const METRICS_FILE = path.join(REPO_ROOT, '.audit_tmp', 'hook-metrics.jsonl');
+const OUTPUT_DIR = path.join(REPO_ROOT, '.audit-reports', 'nightly');
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readMetricsWindow(windowMs) {
+  if (!fs.existsSync(METRICS_FILE)) {
+    return [];
+  }
+
+  const now = Date.now();
+  const cutoff = now - windowMs;
+  const lines = fs.readFileSync(METRICS_FILE, 'utf8').split('\n').filter(Boolean);
+
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.timestamp && parsed.timestamp >= cutoff) {
+        entries.push(parsed);
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  return entries;
+}
+
+function aggregateMetrics(entries) {
+  const summary = {
+    total: entries.length,
+    success: 0,
+    failure: 0,
+    hooks: {}
+  };
+
+  for (const entry of entries) {
+    const status = entry.status || 'unknown';
+    if (status === 'success') {
+      summary.success += 1;
+    } else if (status === 'failure') {
+      summary.failure += 1;
+    }
+
+    const hook = entry.hook || 'unknown';
+    if (!summary.hooks[hook]) {
+      summary.hooks[hook] = {
+        total: 0,
+        success: 0,
+        failure: 0,
+        durations: []
+      };
+    }
+
+    const bucket = summary.hooks[hook];
+    bucket.total += 1;
+    if (status === 'success') {
+      bucket.success += 1;
+    } else if (status === 'failure') {
+      bucket.failure += 1;
+    }
+    if (Number.isFinite(entry.durationMs)) {
+      bucket.durations.push(entry.durationMs);
+    }
+  }
+
+  for (const hook of Object.keys(summary.hooks)) {
+    const bucket = summary.hooks[hook];
+    const count = bucket.durations.length;
+    const totalDuration = bucket.durations.reduce((acc, value) => acc + value, 0);
+    bucket.avgDurationMs = count > 0 ? totalDuration / count : null;
+    delete bucket.durations;
+  }
+
+  return summary;
+}
+
+function formatDate(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(date.getUTCDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function writeReport(report) {
+  ensureDir(OUTPUT_DIR);
+  const dateKey = formatDate(new Date(report.window.end));
+  const outputPath = path.join(OUTPUT_DIR, `hook-metrics-${dateKey}.json`);
+  fs.writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  return outputPath;
+}
+
+function run() {
+  const now = Date.now();
+  const windowMs = 24 * 60 * 60 * 1000;
+  const entries = readMetricsWindow(windowMs);
+  const summary = aggregateMetrics(entries);
+
+  const report = {
+    generatedAt: new Date(now).toISOString(),
+    window: {
+      start: new Date(now - windowMs).toISOString(),
+      end: new Date(now).toISOString()
+    },
+    totals: summary,
+    notes: entries.length === 0 ? 'No metrics recorded in the selected window.' : undefined
+  };
+
+  const outputPath = writeReport(report);
+  console.log(`Nightly metrics report generated: ${outputPath}`);
+}
+
+if (require.main === module) {
+  try {
+    run();
+  } catch (error) {
+    console.error('Failed to generate nightly metrics report:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  readMetricsWindow,
+  aggregateMetrics,
+  writeReport,
+  run
+};

package/scripts/hooks-system/bin/plan-review.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const REVIEW_LOG = path.join(process.cwd(), '.audit_tmp', 'hook-review.log');
+
+function ensureDir(file) {
+  const dir = path.dirname(file);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function nextQuarterDate() {
+  const now = new Date();
+  const quarter = Math.floor(now.getMonth() / 3);
+  const nextQuarter = (quarter + 1) % 4;
+  const year = now.getFullYear() + (nextQuarter === 0 ? 1 : 0);
+  const month = nextQuarter === 0 ? 0 : nextQuarter * 3;
+  return new Date(year, month, 1);
+}
+
+const nextReview = nextQuarterDate();
+ensureDir(REVIEW_LOG);
+fs.appendFileSync(
+  REVIEW_LOG,
+  `${new Date().toISOString()} | next-review | ${nextReview.toISOString()}\n`
+);
+
+console.log(`Próxima auditoría sugerida: ${nextReview.toDateString()}`);

package/scripts/hooks-system/bin/predictive-hooks.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const PredictiveHookAdvisor = require('../application/services/PredictiveHookAdvisor');
+
+const advisor = new PredictiveHookAdvisor();
+const suggestions = advisor.suggestPreemptiveActions();
+
+if (suggestions.length === 0) {
+  console.log('No predictive actions required (insufficient data or low failure rates).');
+  process.exit(0);
+}
+
+console.log('Predictive hook suggestions:');
+for (const suggestion of suggestions) {
+  console.log(
+    `- ${suggestion.hook}: ${(suggestion.probability * 100).toFixed(1)}% failure rate (${suggestion.failures}/${suggestion.total})`
+  );
+}

package/scripts/hooks-system/bin/pumuki-audit.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const path = require('path');
+const fs = require('fs');
+const { toErrorMessage } = require('../infrastructure/utils/error-utils');
+
+async function loadConfig(cwd) {
+    const configPath = path.join(cwd, '.pumuki.config.js');
+    if (fs.existsSync(configPath)) {
+        return require(configPath);
+    }
+    return {
+        platforms: ['backend'],
+        ignore: ['**/node_modules/**', '**/dist/**'],
+        rules: {}
+    };
+}
+
+async function findFiles(cwd, platforms, ignore) {
+    const { glob } = require('glob');
+    const patterns = [];
+
+    if (platforms.includes('backend')) {
+        patterns.push('**/*.ts', '**/*.js');
+    }
+    if (platforms.includes('frontend')) {
+        patterns.push('**/*.tsx', '**/*.jsx');
+    }
+    if (platforms.includes('ios')) {
+        patterns.push('**/*.swift');
+    }
+    if (platforms.includes('android')) {
+        patterns.push('**/*.kt');
+    }
+
+    const files = await glob(patterns, {
+        cwd,
+        ignore,
+        absolute: true,
+        nodir: true
+    });
+
+    return files;
+}
+
+async function runAudit() {
+    const cwd = process.cwd();
+    console.log('🔍 Pumuki Hooks - Full Audit\n');
+
+    const config = await loadConfig(cwd);
+    console.log(`📦 Platforms: ${config.platforms.join(', ')}`);
+
+    const files = await findFiles(cwd, config.platforms, config.ignore);
+    console.log(`📁 Files to analyze: ${files.length}\n`);
+
+    if (files.length === 0) {
+        console.log('✅ No files to analyze.');
+        return;
+    }
+
+    const astIntelligencePath = path.resolve(__dirname, '../infrastructure/ast/ast-intelligence.js');
+    if (!fs.existsSync(astIntelligencePath)) {
+        console.log('⚠️  AST Intelligence not found. Install pumuki-hooks globally or run from project root.');
+        process.exit(1);
+    }
+
+    const { runAstAnalysis } = require(astIntelligencePath);
+
+    let totalFindings = 0;
+    const findingsByPlatform = {};
+
+    for (const file of files.slice(0, 100)) {
+        try {
+            const findings = await runAstAnalysis([file]);
+            if (findings && findings.length > 0) {
+                totalFindings += findings.length;
+                const platform = detectFilePlatform(file);
+                findingsByPlatform[platform] = (findingsByPlatform[platform] || 0) + findings.length;
+            }
+        } catch (error) {
+            console.error(`[pumuki-audit] Failed to analyze file: ${file}`);
+            console.error(`[pumuki-audit] ${toErrorMessage(error)}`);
+            continue;
+        }
+    }
+
+    console.log('\n📊 Audit Results:');
+    console.log(`   Total findings: ${totalFindings}`);
+    for (const [platform, count] of Object.entries(findingsByPlatform)) {
+        console.log(`   ${platform}: ${count}`);
+    }
+
+    if (totalFindings > 0) {
+        console.log('\n⚠️  Run `npx pumuki-hooks audit --fix` to auto-fix where possible.');
+    } else {
+        console.log('\n✅ No violations found!');
+    }
+}
+
+function detectFilePlatform(filePath) {
+    if (filePath.endsWith('.swift')) return 'ios';
+    if (filePath.endsWith('.kt')) return 'android';
+    if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx')) return 'frontend';
+    return 'backend';
+}
+
+if (require.main === module) {
+    runAudit().catch(err => {
+        console.error('Error:', err.message);
+        process.exit(1);
+    });
+}
+
+module.exports = { runAudit, loadConfig };

package/scripts/hooks-system/bin/pumuki-init.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CONFIG_TEMPLATE = `module.exports = {
+  platforms: [],
+  rules: {
+    'backend.security.pii_in_logs': 'error',
+    'backend.api.validation': 'warn',
+    'frontend.solid.srp': 'error',
+    'common.quality.comments': 'warn'
+  },
+  ignore: [
+    '**/node_modules/**',
+    '**/*.spec.ts',
+    '**/*.test.ts',
+    '**/dist/**'
+  ],
+  notifications: {
+    enabled: true,
+    sound: true
+  },
+  gitflow: {
+    protectedBranches: ['main', 'master', 'develop'],
+    requireFeatureBranch: true
+  }
+};
+`;
+
+function detectProjectType(cwd) {
+    const platforms = [];
+
+    if (fs.existsSync(path.join(cwd, 'package.json'))) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+        if (pkg.dependencies?.['@nestjs/core'] || pkg.devDependencies?.['@nestjs/core']) {
+            platforms.push('backend');
+        }
+        if (pkg.dependencies?.react || pkg.dependencies?.next) {
+            platforms.push('frontend');
+        }
+    }
+
+    if (fs.existsSync(path.join(cwd, 'Package.swift')) ||
+        fs.readdirSync(cwd).some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))) {
+        platforms.push('ios');
+    }
+
+    if (fs.existsSync(path.join(cwd, 'build.gradle')) ||
+        fs.existsSync(path.join(cwd, 'build.gradle.kts'))) {
+        platforms.push('android');
+    }
+
+    return platforms.length > 0 ? platforms : ['backend'];
+}
+
+function installGitHooks(cwd) {
+    const hooksDir = path.join(cwd, '.git', 'hooks');
+    if (!fs.existsSync(hooksDir)) {
+        console.log('⚠️  No .git directory found. Initialize git first.');
+        return false;
+    }
+
+    const preCommitPath = path.join(hooksDir, 'pre-commit');
+    const hookContent = `#!/bin/sh
+# Pumuki Hooks - Pre-commit
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+"$REPO_ROOT/scripts/hooks-system/infrastructure/guards/master-validator.sh"
+`;
+
+    fs.writeFileSync(preCommitPath, hookContent);
+    fs.chmodSync(preCommitPath, '755');
+    return true;
+}
+
+function main() {
+    const cwd = process.cwd();
+    console.log('🚀 Pumuki Hooks - Initializing...\n');
+
+    const platforms = detectProjectType(cwd);
+    console.log(`📦 Detected platforms: ${platforms.join(', ')}`);
+
+    const configPath = path.join(cwd, '.pumuki.config.js');
+    if (fs.existsSync(configPath)) {
+        console.log('⚠️  .pumuki.config.js already exists. Skipping.');
+    } else {
+        const config = CONFIG_TEMPLATE.replace('platforms: []', `platforms: ${JSON.stringify(platforms)}`);
+        fs.writeFileSync(configPath, config);
+        console.log('✅ Created .pumuki.config.js');
+    }
+
+    if (installGitHooks(cwd)) {
+        console.log('✅ Git hooks installed');
+    }
+
+    console.log('\n🎉 Pumuki Hooks initialized successfully!');
+    console.log('   Run `node scripts/hooks-system/bin/pumuki-audit.js` to analyze your code.');
+}
+
+if (require.main === module) {
+    main();
+}
+
+module.exports = { detectProjectType, installGitHooks };

package/scripts/hooks-system/bin/pumuki-mcp.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MCP_CONFIG = {
+    mcpServers: {
+        'ast-intelligence-automation': {
+            command: 'node',
+            type: 'stdio',
+            args: ['./scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js'],
+            env: {
+                REPO_ROOT: process.cwd()
+            }
+        }
+    }
+};
+
+function detectIDE() {
+    const cursorConfig = path.join(os.homedir(), '.cursor');
+    const windsurfConfig = path.join(os.homedir(), '.windsurf');
+    const vscodeConfig = path.join(os.homedir(), '.vscode');
+
+    if (fs.existsSync(cursorConfig)) return { name: 'Cursor', path: cursorConfig };
+    if (fs.existsSync(windsurfConfig)) return { name: 'Windsurf', path: windsurfConfig };
+    if (fs.existsSync(vscodeConfig)) return { name: 'VSCode', path: vscodeConfig };
+
+    return null;
+}
+
+function configureMCP() {
+    const cwd = process.cwd();
+    console.log('🔌 Pumuki Hooks - MCP Configuration\n');
+
+    const ide = detectIDE();
+    if (!ide) {
+        console.log('⚠️  No supported IDE detected (Cursor, Windsurf, VSCode)');
+        console.log('   Creating local .cursor/mcp.json instead.\n');
+    } else {
+        console.log(`✅ Detected IDE: ${ide.name}`);
+    }
+
+    const mcpDir = path.join(cwd, '.cursor');
+    const mcpFile = path.join(mcpDir, 'mcp.json');
+
+    if (!fs.existsSync(mcpDir)) {
+        fs.mkdirSync(mcpDir, { recursive: true });
+    }
+
+    const config = JSON.parse(JSON.stringify(MCP_CONFIG));
+    config.mcpServers['ast-intelligence-automation'].args[0] =
+        path.join(cwd, 'scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js');
+    config.mcpServers['ast-intelligence-automation'].env.REPO_ROOT = cwd;
+
+    if (fs.existsSync(mcpFile)) {
+        const existing = JSON.parse(fs.readFileSync(mcpFile, 'utf8'));
+        existing.mcpServers = { ...existing.mcpServers, ...config.mcpServers };
+        fs.writeFileSync(mcpFile, JSON.stringify(existing, null, 2));
+        console.log('✅ Updated existing .cursor/mcp.json');
+    } else {
+        fs.writeFileSync(mcpFile, JSON.stringify(config, null, 2));
+        console.log('✅ Created .cursor/mcp.json');
+    }
+
+    console.log('\n📋 MCP Server configured:');
+    console.log('   - ast-intelligence-automation');
+    console.log('\n🔄 Restart your IDE to activate the MCP server.');
+}
+
+if (require.main === module) {
+    configureMCP();
+}
+
+module.exports = { configureMCP, detectIDE };

package/scripts/hooks-system/bin/pumuki-rules.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+function extractRulesFromFiles(dir, rules) {
+    if (!fs.existsSync(dir)) return;
+
+    fs.readdirSync(dir, { withFileTypes: true }).forEach(entry => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            extractRulesFromFiles(fullPath, rules);
+        } else if (entry.name.endsWith('.js')) {
+            try {
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const matches = content.matchAll(/pushFileFinding\s*\(\s*['"]([^'"]+)['"]/g);
+                for (const match of matches) {
+                    const ruleId = match[1];
+                    const platform = ruleId.split('.')[0];
+                    if (!rules[platform]) rules[platform] = new Set();
+                    rules[platform].add(ruleId);
+                }
+                const matches2 = content.matchAll(/pushFinding\s*\(\s*['"]([^'"]+)['"]/g);
+                for (const match of matches2) {
+                    const ruleId = match[1];
+                    const platform = ruleId.split('.')[0];
+                    if (!rules[platform]) rules[platform] = new Set();
+                    rules[platform].add(ruleId);
+                }
+            } catch (error) {
+                return;
+            }
+        }
+    });
+}
+
+function guessSeverity(ruleId) {
+    if (/critical|security|pii|leak|injection/.test(ruleId)) return 'CRITICAL';
+    if (/solid|architecture|force_unwrap|god_class/.test(ruleId)) return 'HIGH';
+    if (/missing|warning/.test(ruleId)) return 'MEDIUM';
+    return 'LOW';
+}
+
+function listRules(platform) {
+    console.log('📋 AST Intelligence Hooks - Available Rules\n');
+
+    const astDir = path.join(__dirname, '../infrastructure/ast');
+    const rulesMap = {};
+    extractRulesFromFiles(astDir, rulesMap);
+
+    const platforms = platform ? [platform] : Object.keys(rulesMap).sort();
+    let total = 0;
+
+    platforms.forEach(p => {
+        const ruleSet = rulesMap[p];
+        if (!ruleSet || ruleSet.size === 0) return;
+
+        const rulesList = Array.from(ruleSet).sort();
+        console.log(`\n## ${p.toUpperCase()} (${rulesList.length} rules)\n`);
+
+        rulesList.forEach(ruleId => {
+            const sev = guessSeverity(ruleId);
+            const icon = { CRITICAL: '🔴', HIGH: '🟠', MEDIUM: '🟡', LOW: '🟢' }[sev];
+            console.log(`  ${icon} ${ruleId}`);
+        });
+        total += rulesList.length;
+    });
+
+    console.log(`\n\n📊 Total: ${total} rules`);
+}
+
+const platform = process.argv[2];
+listRules(platform);
+
+module.exports = { extractRulesFromFiles, listRules };

package/scripts/hooks-system/bin/request-no-verify-approval.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+
+# Script de solicitud de aprobación para --no-verify
+# Este script DEBE ser llamado por la IA antes de usar --no-verify
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+echo ""
+echo -e "${RED}${BOLD}╔═════════════════════════════════════════════════════════════╗${NC}"
+echo -e "${RED}${BOLD}║  🚨 AI REQUESTING --no-verify AUTHORIZATION                ║${NC}"
+echo -e "${RED}${BOLD}╚═════════════════════════════════════════════════════════════╝${NC}"
+echo ""
+
+echo -e "${YELLOW}${BOLD}GIT HOOK BLOCKED COMMIT${NC}"
+echo -e "${BLUE}─────────────────────────────────────────────────────────────${NC}"
+echo ""
+
+# Obtener violations de staging del último audit
+if [ -f /tmp/r_go_local/pattern-staged.txt ]; then
+  echo -e "${CYAN}Violations detected in STAGING AREA:${NC}"
+  echo ""
+
+  CRIT=$(grep "^CRITICAL:" /tmp/r_go_local/pattern-staged.txt 2>/dev/null | cut -d: -f2 || echo "0")
+  HIGH=$(grep "^HIGH:" /tmp/r_go_local/pattern-staged.txt 2>/dev/null | cut -d: -f2 || echo "0")
+  MED=$(grep "^MEDIUM:" /tmp/r_go_local/pattern-staged.txt 2>/dev/null | cut -d: -f2 || echo "0")
+  LOW=$(grep "^LOW:" /tmp/r_go_local/pattern-staged.txt 2>/dev/null | cut -d: -f2 || echo "0")
+
+  echo -e "  ${RED}🔴 CRITICAL:${NC} ${CRIT:-0}"
+  echo -e "  ${YELLOW}🟠 HIGH:${NC}     ${HIGH:-0}"
+  echo -e "  ${YELLOW}🟡 MEDIUM:${NC}   ${MED:-0}"
+  echo -e "  ${BLUE}🔵 LOW:${NC}      ${LOW:-0}"
+  echo ""
+fi
+
+# Mostrar información del branch actual
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+echo -e "${CYAN}Current branch:${NC} ${YELLOW}${BRANCH}${NC}"
+echo ""
+
+# Obtener archivos staged
+STAGED_FILES=$(git diff --cached --name-only | wc -l | tr -d ' ')
+echo -e "${CYAN}Files in staging:${NC} ${STAGED_FILES}"
+git diff --cached --name-status | head -10 | sed 's/^/  /'
+if [ "$STAGED_FILES" -gt 10 ]; then
+  echo "  ... and $((STAGED_FILES - 10)) more files"
+fi
+echo ""
+
+echo -e "${BLUE}─────────────────────────────────────────────────────────────${NC}"
+echo ""
+echo -e "${YELLOW}${BOLD}⚠️  AI NEEDS YOUR DECISION:${NC}"
+echo ""
+echo -e "  ${GREEN}${BOLD}A)${NC} Fix the violations now (stay strict)"
+echo -e "     ${BLUE}→${NC} AI will analyze and fix detected violations"
+echo -e "     ${BLUE}→${NC} Commit will be clean"
+echo ""
+echo -e "  ${YELLOW}${BOLD}B)${NC} Authorize --no-verify (bypass hook)"
+echo -e "     ${BLUE}→${NC} AI will commit with --no-verify"
+echo -e "     ${BLUE}→${NC} Violations will be documented in commit message"
+echo -e "     ${BLUE}→${NC} You can verify later with: verify-policy command"
+echo ""
+echo -e "${BLUE}─────────────────────────────────────────────────────────────${NC}"
+echo ""
+echo -e "${CYAN}${BOLD}Type your choice:${NC}"
+echo -e "  'A' or 'fix'       → Fix violations"
+echo -e "  'B' or 'authorize' → Authorize --no-verify"
+echo -e "  'cancel'           → Cancel commit"
+echo ""
+read -p "Your choice: " choice
+
+case "${choice,,}" in
+  a|fix)
+    echo ""
+    echo -e "${GREEN}✅ User chose: FIX VIOLATIONS${NC}"
+    echo -e "${YELLOW}AI will now analyze and fix the violations...${NC}"
+    echo ""
+    exit 10
+    ;;
+  b|authorize|autorizo)
+    echo ""
+    echo -e "${YELLOW}✅ User AUTHORIZED --no-verify${NC}"
+    echo ""
+    read -p "Reason for authorization: " reason
+    echo ""
+    echo -e "${GREEN}Authorization granted:${NC}"
+    echo -e "  Reason: ${reason}"
+    echo ""
+    echo -e "${YELLOW}AI will now commit with --no-verify and document authorization${NC}"
+    echo ""
+    # Guardar la autorización en un archivo temporal para que la IA la use
+    echo "AUTHORIZED by @carlos-merlos" > /tmp/no_verify_approval.txt
+    echo "Reason: $reason" >> /tmp/no_verify_approval.txt
+    echo "Timestamp: $(date)" >> /tmp/no_verify_approval.txt
+    exit 0
+    ;;
+  cancel|c)
+    echo ""
+    echo -e "${RED}❌ Commit cancelled by user${NC}"
+    echo ""
+    exit 1
+    ;;
+  *)
+    echo ""
+    echo -e "${RED}❌ Invalid choice. Commit cancelled.${NC}"
+    echo ""
+    exit 1
+    ;;
+esac