pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/bin/auto-fix-violations.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const AUDIT_FILE = path.join(ROOT, '.audit_tmp', 'ast-summary.json');
+
+const FIXES = {
+    'common.quality.comments': fixComments,
+    'common.debug.console': fixConsoleLog,
+    'common.quality.todo_fixme': null,
+    'common.quality.disabled_lint': null,
+};
+
+if (fs.existsSync(AUDIT_FILE)) {
+    fs.readFileSync(AUDIT_FILE, 'utf-8');
+}
+
+function loadAuditData() {
+    if (!fs.existsSync(AUDIT_FILE)) {
+        process.stderr.write('❌ No audit data found. Run audit first.\n');
+        process.exit(1);
+    }
+    return JSON.parse(fs.readFileSync(AUDIT_FILE, 'utf-8'));
+}
+
+function fixComments(filePath) {
+    const absPath = path.join(ROOT, filePath);
+    if (!fs.existsSync(absPath)) return { fixed: 0, skipped: 1 };
+
+    let content = fs.readFileSync(absPath, 'utf-8');
+    const original = content;
+
+    // Remove single-line comment markers
+    content = content.replace(/\/\/\s*(TODO|FIXME|HACK|XXX)[^\n]*\n?/gi, '');
+    // Remove block TODO comments
+    content = content.replace(/\/\*\s*TODO[\s\S]*?\*\//gi, '');
+
+    content = content.replace(/\n{3,}/g, '\n\n');
+
+    if (content !== original) {
+        fs.writeFileSync(absPath, content, 'utf-8');
+        return { fixed: 1, skipped: 0 };
+    }
+    return { fixed: 0, skipped: 1 };
+}
+
+function fixConsoleLog(filePath) {
+    const absPath = path.join(ROOT, filePath);
+    if (!fs.existsSync(absPath)) return { fixed: 0, skipped: 1 };
+
+    if (filePath.includes('.spec.') || filePath.includes('.test.') || filePath.includes('__tests__')) {
+        return { fixed: 0, skipped: 1 };
+    }
+
+    let content = fs.readFileSync(absPath, 'utf-8');
+    const original = content;
+
+    content = content.replace(/console\.log\([^)]*\);?\n?/g, '');
+    content = content.replace(/console\.debug\([^)]*\);?\n?/g, '');
+
+    content = content.replace(/\n{3,}/g, '\n\n');
+
+    if (content !== original) {
+        fs.writeFileSync(absPath, content, 'utf-8');
+        return { fixed: 1, skipped: 0 };
+    }
+    return { fixed: 0, skipped: 1 };
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    const dryRun = args.includes('--dry-run');
+    const ruleFilter = args.find(a => a.startsWith('--rule='))?.split('=')[1];
+
+    process.stdout.write('🔧 AST Auto-Fix Tool\n');
+    process.stdout.write('====================\n\n');
+
+    if (dryRun) process.stdout.write('🔍 DRY RUN - No changes will be made\n\n');
+
+    const audit = loadAuditData();
+    const stats = { total: 0, fixed: 0, skipped: 0, noFix: 0 };
+
+    for (const [rule, fixer] of Object.entries(FIXES)) {
+        if (ruleFilter && rule !== ruleFilter) continue;
+
+        const ruleData = audit.ruleDetails?.[rule];
+        if (!ruleData) continue;
+
+        process.stdout.write(`\n📋 ${rule} (${ruleData.count} violations)\n`);
+
+        if (!fixer) {
+            process.stdout.write('   ⏭️  No auto-fix available\n');
+            stats.noFix += ruleData.count;
+            continue;
+        }
+
+        for (const file of ruleData.files || []) {
+            stats.total++;
+            if (dryRun) {
+                process.stdout.write(`   Would fix: ${file}\n`);
+                stats.fixed++;
+            } else {
+                const result = fixer(file);
+                stats.fixed += result.fixed;
+                stats.skipped += result.skipped;
+                if (result.fixed) process.stdout.write(`   ✅ Fixed: ${file}\n`);
+            }
+        }
+    }
+
+    process.stdout.write('\n====================\n');
+    process.stdout.write('📊 Summary:\n');
+    process.stdout.write(`   Total files processed: ${stats.total}\n`);
+    process.stdout.write(`   Fixed: ${stats.fixed}\n`);
+    process.stdout.write(`   Skipped: ${stats.skipped}\n`);
+    process.stdout.write(`   No auto-fix: ${stats.noFix}\n`);
+}
+
+if (require.main === module) {
+    main();
+}
+
+module.exports = {
+    loadAuditData,
+    fixComments,
+    fixConsoleLog,
+    FIXES
+};

package/scripts/hooks-system/bin/auto-restart-guards.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const repoRoot = process.cwd();
+const debounceMs = Number(process.env.HOOK_GUARD_AUTORELOAD_DEBOUNCE || 1500);
+const restartCmd = path.join(repoRoot, 'bin', 'start-guards.sh');
+
+const targets = [
+  'bin/watch-hooks.js',
+  'application/services/RealtimeGuardService.js',
+  'infrastructure/watchdog/token-monitor-loop.sh',
+  'infrastructure/watchdog/token-monitor.js',
+  'infrastructure/watchdog/token-tracker.sh',
+  'bin/start-guards.sh'
+];
+
+let restartTimer = null;
+
+const watchers = [];
+
+function log(message) {
+  const timestamp = new Date().toISOString();
+  console.log(`[guard-auto-reload ${timestamp}] ${message}`);
+}
+
+function scheduleRestart(reason) {
+  if (restartTimer) {
+    return;
+  }
+  log(`Change detected (${reason}). Restarting guards in ${debounceMs}ms`);
+  restartTimer = setTimeout(() => {
+    try {
+      const child = spawn(restartCmd, ['restart'], {
+        cwd: repoRoot,
+        detached: true,
+        stdio: 'ignore'
+      });
+      child.unref();
+    } catch (error) {
+      log(`Failed to launch restart: ${error.message}`);
+    } finally {
+      process.exit(0);
+    }
+  }, debounceMs);
+  if (typeof restartTimer.unref === 'function') {
+    restartTimer.unref();
+  }
+}
+
+function watchFile(relativePath) {
+  const absolute = path.join(repoRoot, relativePath);
+  const dir = path.dirname(absolute);
+  const file = path.basename(absolute);
+
+  if (!fs.existsSync(absolute)) {
+    log(`Warning: ${relativePath} not found; auto-reload will ignore it.`);
+    return;
+  }
+
+  try {
+    const watcher = fs.watch(dir, (event, filename) => {
+      if (!filename) {
+        return;
+      }
+      if (filename.toString() === file) {
+        scheduleRestart(`${relativePath}:${event}`);
+      }
+    });
+    watchers.push(watcher);
+  } catch (error) {
+    log(`Error watching ${relativePath}: ${error.message}`);
+  }
+}
+
+function shutdown() {
+  watchers.forEach(w => {
+    try {
+      w.close();
+    } catch (error) {
+      log(`Error closing watcher: ${error.message}`); 
+    }
+  });
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+log('Auto-restart guard running');
+targets.forEach(watchFile);
+
+setInterval(() => {}, 1 << 30);

package/scripts/hooks-system/bin/check-doc-drift.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'doc-standards.json');
+const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+
+let hasError = false;
+
+for (const docPath of config.requiredDocs) {
+  const absolute = path.join(process.cwd(), docPath);
+  if (!fs.existsSync(absolute)) {
+    console.error(`❌ Missing doc: ${docPath}`);
+    hasError = true;
+    continue;
+  }
+
+  const stats = fs.statSync(absolute);
+  if (stats.size === 0) {
+    console.error(`❌ Empty doc: ${docPath}`);
+    hasError = true;
+  }
+
+  const ageDays = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60 * 24);
+  if (ageDays > config.maxAgeDays) {
+    console.warn(`⚠️  Doc older than ${config.maxAgeDays} days: ${docPath}`);
+  }
+}
+
+if (hasError) {
+  process.exit(1);
+}
+
+console.log('Documentation standards check complete');

package/scripts/hooks-system/bin/check-version.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * Check installed version vs latest available
+ * Helps detect when updates are available
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m'
+};
+
+function getInstalledVersion() {
+  const projectRoot = process.cwd();
+  
+  try {
+    const packageJsonPath = require.resolve('@pumuki/ast-intelligence-hooks/package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const packageRoot = path.dirname(path.dirname(packageJsonPath));
+    
+    const projectPkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(projectPkgPath)) {
+      const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, 'utf-8'));
+      const deps = { ...projectPkg.dependencies, ...projectPkg.devDependencies };
+      const depVersion = deps['@pumuki/ast-intelligence-hooks'];
+      
+      if (depVersion && depVersion.startsWith('file:')) {
+        return { version: pkg.version, type: 'local', path: packageRoot };
+      }
+    }
+    
+    return { version: pkg.version, type: 'npm', path: packageRoot };
+  } catch (err) {
+    err = null;
+    // Fallback: continue with local project dependency checks
+  }
+  
+  const projectPkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(projectPkgPath)) {
+    const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, 'utf-8'));
+    const deps = { ...projectPkg.dependencies, ...projectPkg.devDependencies };
+    
+    if (deps['@pumuki/ast-intelligence-hooks']) {
+      let version = deps['@pumuki/ast-intelligence-hooks'];
+      
+      if (version.startsWith('file:')) {
+        const libPath = path.resolve(projectRoot, version.replace('file:', ''));
+        const libPackageJson = path.join(libPath, 'package.json');
+        if (fs.existsSync(libPackageJson)) {
+          const libPkg = JSON.parse(fs.readFileSync(libPackageJson, 'utf-8'));
+          return { version: libPkg.version, type: 'local', path: libPath };
+        }
+        return { version: 'unknown (local)', type: 'local', path: libPath };
+      }
+      
+      const nodeModulesPath = path.join(projectRoot, 'node_modules', '@pumuki', 'ast-intelligence-hooks', 'package.json');
+      if (fs.existsSync(nodeModulesPath)) {
+        const installedPkg = JSON.parse(fs.readFileSync(nodeModulesPath, 'utf-8'));
+        return { version: installedPkg.version, type: 'npm', declaredVersion: version };
+      }
+      
+      return { version: version.replace(/^[\^~]/, ''), type: 'npm', declaredVersion: version };
+    }
+  }
+  
+  const nodeModulesPath = path.join(projectRoot, 'node_modules', '@pumuki', 'ast-intelligence-hooks', 'package.json');
+  if (fs.existsSync(nodeModulesPath)) {
+    const pkg = JSON.parse(fs.readFileSync(nodeModulesPath, 'utf-8'));
+    return { version: pkg.version, type: 'npm' };
+  }
+  
+  const scriptsPath = path.join(projectRoot, 'scripts', 'hooks-system');
+  if (fs.existsSync(scriptsPath)) {
+    return { version: 'unknown', type: 'partial', message: 'Scripts installed but package not found in node_modules' };
+  }
+  
+  return null;
+}
+
+function getLatestVersion() {
+  try {
+    // Try npm view
+    const output = execSync('npm view @pumuki/ast-intelligence-hooks version', { 
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000
+    });
+    return output.trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+
+function main() {
+  console.log(`${COLORS.blue}╔══════════════════════════════════════════════════════════════╗${COLORS.reset}`);
+  console.log(`${COLORS.blue}║     AST Intelligence Hooks - Version Check                   ║${COLORS.reset}`);
+  console.log(`${COLORS.blue}╚══════════════════════════════════════════════════════════════╝${COLORS.reset}\n`);
+  
+  const installed = getInstalledVersion();
+  
+  if (!installed) {
+    console.log(`${COLORS.red}❌ ast-intelligence-hooks not found in this project${COLORS.reset}`);
+    console.log(`\n${COLORS.cyan}Install it with:${COLORS.reset}`);
+    console.log(`  npm install --save-dev @pumuki/ast-intelligence-hooks`);
+    console.log(`  npm run install-hooks\n`);
+    process.exit(1);
+  }
+  
+  console.log(`${COLORS.cyan}Installed version:${COLORS.reset}`);
+  console.log(`  ${COLORS.green}${installed.version}${COLORS.reset} (${installed.type})`);
+  if (installed.path) {
+    console.log(`  Path: ${installed.path}`);
+  }
+  if (installed.declaredVersion) {
+    console.log(`  Declared in package.json: ${installed.declaredVersion}`);
+  }
+  if (installed.message) {
+    console.log(`  ${COLORS.yellow}⚠️  ${installed.message}${COLORS.reset}`);
+  }
+  console.log();
+  
+  if (installed.type === 'local') {
+    console.log(`${COLORS.yellow}ℹ️  Using local installation (development mode)${COLORS.reset}`);
+    console.log(`  Updates come from the linked library directory.\n`);
+    process.exit(0);
+  }
+  
+  if (installed.type === 'partial') {
+    console.log(`${COLORS.yellow}⚠️  Partial installation detected${COLORS.reset}`);
+    console.log(`  It seems hooks are installed but the package is missing.\n`);
+    console.log(`${COLORS.cyan}Try reinstalling:${COLORS.reset}`);
+    console.log(`  npm install --save-dev @pumuki/ast-intelligence-hooks`);
+    console.log(`  npm run install-hooks\n`);
+    process.exit(0);
+  }
+  
+  if (installed.version === 'unknown') {
+    console.log(`${COLORS.red}❌ Cannot determine installed version${COLORS.reset}\n`);
+    process.exit(1);
+  }
+  
+  console.log(`${COLORS.cyan}Checking latest version on npm...${COLORS.reset}`);
+  const latest = getLatestVersion();
+  
+  if (!latest) {
+    console.log(`${COLORS.yellow}⚠️  Could not check latest version (network issue or package not published)${COLORS.reset}\n`);
+    process.exit(0);
+  }
+  
+  console.log(`  Latest: ${COLORS.green}${latest}${COLORS.reset}\n`);
+  
+  const comparison = compareVersions(installed.version, latest);
+  
+  if (comparison < 0) {
+    console.log(`${COLORS.yellow}⚠️  UPDATE AVAILABLE${COLORS.reset}`);
+    console.log(`\n${COLORS.cyan}To update:${COLORS.reset}`);
+    console.log(`  1. Update package:${COLORS.reset}`);
+    console.log(`     npm install --save-dev @pumuki/ast-intelligence-hooks@latest`);
+    console.log(`\n  2. Re-install hooks (to get latest features):${COLORS.reset}`);
+    console.log(`     npm run install-hooks`);
+    console.log(`\n${COLORS.cyan}What's new in ${latest}:${COLORS.reset}`);
+    console.log(`  Check CHANGELOG.md: https://github.com/SwiftEnProfundidad/ast-intelligence-hooks/blob/main/CHANGELOG.md\n`);
+    process.exit(0);
+  } else if (comparison > 0) {
+    console.log(`${COLORS.green}✅ You're running a newer version than published${COLORS.reset}`);
+    console.log(`  This might be a development or beta version.\n`);
+    process.exit(0);
+  } else {
+    // Same version
+    console.log(`${COLORS.green}✅ You're up to date!${COLORS.reset}\n`);
+    process.exit(0);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { getInstalledVersion, getLatestVersion, compareVersions };
+

package/scripts/hooks-system/bin/cleanup-branches.sh

@@ -0,0 +1,106 @@
+#!/bin/bash
+# ═══════════════════════════════════════════════════════════════
+# Cleanup Merged Branches
+# ═══════════════════════════════════════════════════════════════
+# Limpia ramas locales y remotas mergeadas
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+cd "$REPO_ROOT"
+
+DRY_RUN="${1:-}"
+
+echo "🧹 Cleaning up merged branches..."
+echo ""
+
+# Fetch latest
+echo "📥 Fetching latest from remote..."
+git fetch --prune origin
+
+# Local branches merged into main
+echo ""
+echo "📋 Local branches merged into main:"
+LOCAL_MERGED_MAIN=$(git branch --merged origin/main | grep -v "^\*" | grep -v "main\|develop" | sed 's/^[[:space:]]*//' || true)
+
+if [[ -z "$LOCAL_MERGED_MAIN" ]]; then
+  echo "   (none)"
+else
+  echo "$LOCAL_MERGED_MAIN" | while read -r branch; do
+    echo "   - $branch"
+  done
+fi
+
+# Local branches merged into develop
+echo ""
+echo "📋 Local branches merged into develop:"
+LOCAL_MERGED_DEVELOP=$(git branch --merged origin/develop | grep -v "^\*" | grep -v "main\|develop" | sed 's/^[[:space:]]*//' || true)
+
+if [[ -z "$LOCAL_MERGED_DEVELOP" ]]; then
+  echo "   (none)"
+else
+  echo "$LOCAL_MERGED_DEVELOP" | while read -r branch; do
+    echo "   - $branch"
+  done
+fi
+
+# Remote branches merged into main
+echo ""
+echo "📋 Remote branches merged into main:"
+REMOTE_MERGED_MAIN=$(git branch -r --merged origin/main | grep -v "origin/main\|origin/HEAD\|origin/develop" | sed 's|origin/||' | sed 's/^[[:space:]]*//' || true)
+
+if [[ -z "$REMOTE_MERGED_MAIN" ]]; then
+  echo "   (none)"
+else
+  echo "$REMOTE_MERGED_MAIN" | head -20
+  if [[ $(echo "$REMOTE_MERGED_MAIN" | wc -l) -gt 20 ]]; then
+    echo "   ... and $(( $(echo "$REMOTE_MERGED_MAIN" | wc -l) - 20 )) more"
+  fi
+fi
+
+# Summary
+TOTAL_LOCAL=$(echo -e "$LOCAL_MERGED_MAIN\n$LOCAL_MERGED_DEVELOP" | grep -v "^$" | sort -u | wc -l | xargs)
+TOTAL_REMOTE=$(echo "$REMOTE_MERGED_MAIN" | grep -v "^$" | wc -l | xargs)
+
+echo ""
+echo "═══════════════════════════════════════════════════════════════"
+echo "📊 Summary:"
+echo "   Local branches to delete: $TOTAL_LOCAL"
+echo "   Remote branches to delete: $TOTAL_REMOTE"
+echo "═══════════════════════════════════════════════════════════════"
+echo ""
+
+if [[ "$DRY_RUN" == "--dry-run" ]]; then
+  echo "🔍 DRY RUN MODE - No branches will be deleted"
+  echo ""
+  echo "To actually delete branches, run:"
+  echo "  $0"
+  exit 0
+fi
+
+# Delete local branches
+if [[ -n "$LOCAL_MERGED_MAIN" ]] || [[ -n "$LOCAL_MERGED_DEVELOP" ]]; then
+  echo "🗑️  Deleting local merged branches..."
+  echo -e "$LOCAL_MERGED_MAIN\n$LOCAL_MERGED_DEVELOP" | grep -v "^$" | sort -u | while read -r branch; do
+    if git show-ref --verify --quiet refs/heads/"$branch"; then
+      echo "   Deleting local: $branch"
+      git branch -d "$branch" 2>/dev/null || git branch -D "$branch" 2>/dev/null || true
+    fi
+  done
+fi
+
+# Delete remote branches (requires confirmation)
+if [[ -n "$REMOTE_MERGED_MAIN" ]] && [[ $TOTAL_REMOTE -gt 0 ]]; then
+  echo ""
+  echo "🗑️  Deleting remote merged branches..."
+  echo "$REMOTE_MERGED_MAIN" | while read -r branch; do
+    if [[ -n "$branch" ]]; then
+      echo "   Deleting remote: origin/$branch"
+      git push origin --delete "$branch" 2>/dev/null || true
+    fi
+  done
+fi
+
+echo ""
+echo "✅ Cleanup complete!"
+echo ""