pumuki-ast-hooks 5.5.37 → 5.5.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.37",
+  "version": "5.5.40",
   "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": {

package/scripts/hooks-system/application/services/installation/InstallService.js

@@ -157,7 +157,10 @@ class InstallService {
         this.logStep('7/8', 'Installing Git hooks...');
         this.gitService.installGitHooks();
 
-        this.logStep('7.5/8', 'Configuring VS Code/Cursor tasks for auto-start...');
+        this.logStep('7.5/8', 'Cleaning up duplicate rule files...');
+        this.cleanupDuplicateRules();
+
+        this.logStep('7.75/8', 'Configuring VS Code/Cursor tasks for auto-start...');
         this.ideIntegration.configureVSCodeTasks();
 
         this.logStep('8/8', 'Adding npm scripts to package.json...');
@@ -205,6 +208,55 @@ class InstallService {
         }
     }
 
+    cleanupDuplicateRules() {
+        const cleanupEnabled = env.getBool('HOOK_CLEANUP_DUPLICATES', false);
+        if (!cleanupEnabled) {
+            this.logStep('7.75/8', 'Skipping duplicate cleanup (disabled via HOOK_CLEANUP_DUPLICATES)');
+            return;
+        }
+
+        this.logStep('7.75/8', 'Cleaning up duplicate rule files (.md when .mdc exists)...');
+
+        const rulesDirs = [
+            path.join(this.targetRoot, '.cursor', 'rules'),
+            path.join(this.targetRoot, '.windsurf', 'rules')
+        ];
+
+        let deletedCount = 0;
+
+        for (const rulesDir of rulesDirs) {
+            if (!fs.existsSync(rulesDir)) {
+                continue;
+            }
+
+            try {
+                const files = fs.readdirSync(rulesDir);
+                for (const file of files) {
+                    if (!file.endsWith('.md')) {
+                        continue;
+                    }
+
+                    const mdPath = path.join(rulesDir, file);
+                    const mdcPath = path.join(rulesDir, file + 'c');
+
+                    if (fs.existsSync(mdcPath)) {
+                        fs.unlinkSync(mdPath);
+                        deletedCount++;
+                        this.logger.info('DUPLICATE_RULE_DELETED', { file: mdPath });
+                    }
+                }
+            } catch (error) {
+                this.logWarning(`Failed to cleanup duplicates in ${rulesDir}: ${error.message}`);
+            }
+        }
+
+        if (deletedCount > 0) {
+            this.logSuccess(`Cleaned up ${deletedCount} duplicate .md files`);
+        } else {
+            this.logSuccess('No duplicate .md files found');
+        }
+    }
+
     printHeader() {
         const versionPadded = `v${this.version}`.padStart(24).padEnd(48);
         process.stdout.write(`${COLORS.blue}

package/scripts/hooks-system/bin/__tests__/install.spec.js

@@ -9,3 +9,86 @@ describe('install', () => {
     expect(() => require.resolve('../install.js')).not.toThrow();
   });
 });
+
+describe('InstallService - cleanupDuplicateRules', () => {
+  const fs = require('fs');
+  const path = require('path');
+  const InstallService = require('../../application/services/installation/InstallService');
+
+  let testRoot;
+  let service;
+
+  beforeEach(() => {
+    testRoot = path.join(__dirname, '.tmp-cleanup-test');
+    fs.mkdirSync(testRoot, { recursive: true });
+    service = new InstallService();
+    service.targetRoot = testRoot;
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testRoot)) {
+      fs.rmSync(testRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('should skip cleanup when HOOK_CLEANUP_DUPLICATES is false', () => {
+    process.env.HOOK_CLEANUP_DUPLICATES = 'false';
+    service.cleanupDuplicateRules();
+    expect(fs.existsSync(testRoot)).toBe(true);
+  });
+
+  it('should skip cleanup when HOOK_CLEANUP_DUPLICATES is not set', () => {
+    delete process.env.HOOK_CLEANUP_DUPLICATES;
+    service.cleanupDuplicateRules();
+    expect(fs.existsSync(testRoot)).toBe(true);
+  });
+
+  it('should delete .md files when .mdc exists and cleanup is enabled', () => {
+    process.env.HOOK_CLEANUP_DUPLICATES = 'true';
+
+    const cursorRules = path.join(testRoot, '.cursor', 'rules');
+    fs.mkdirSync(cursorRules, { recursive: true });
+
+    fs.writeFileSync(path.join(cursorRules, 'test.md'), 'duplicate');
+    fs.writeFileSync(path.join(cursorRules, 'test.mdc'), 'canonical');
+
+    service.cleanupDuplicateRules();
+
+    expect(fs.existsSync(path.join(cursorRules, 'test.md'))).toBe(false);
+    expect(fs.existsSync(path.join(cursorRules, 'test.mdc'))).toBe(true);
+  });
+
+  it('should not delete .md files when .mdc does not exist', () => {
+    process.env.HOOK_CLEANUP_DUPLICATES = 'true';
+
+    const cursorRules = path.join(testRoot, '.cursor', 'rules');
+    fs.mkdirSync(cursorRules, { recursive: true });
+
+    fs.writeFileSync(path.join(cursorRules, 'test.md'), 'only md');
+
+    service.cleanupDuplicateRules();
+
+    expect(fs.existsSync(path.join(cursorRules, 'test.md'))).toBe(true);
+  });
+
+  it('should cleanup both .cursor and .windsurf rules directories', () => {
+    process.env.HOOK_CLEANUP_DUPLICATES = 'true';
+
+    const cursorRules = path.join(testRoot, '.cursor', 'rules');
+    const windsurfRules = path.join(testRoot, '.windsurf', 'rules');
+    fs.mkdirSync(cursorRules, { recursive: true });
+    fs.mkdirSync(windsurfRules, { recursive: true });
+
+    fs.writeFileSync(path.join(cursorRules, 'cursor.md'), 'duplicate');
+    fs.writeFileSync(path.join(cursorRules, 'cursor.mdc'), 'canonical');
+    fs.writeFileSync(path.join(windsurfRules, 'windsurf.md'), 'duplicate');
+    fs.writeFileSync(path.join(windsurfRules, 'windsurf.mdc'), 'canonical');
+
+    service.cleanupDuplicateRules();
+
+    expect(fs.existsSync(path.join(cursorRules, 'cursor.md'))).toBe(false);
+    expect(fs.existsSync(path.join(cursorRules, 'cursor.mdc'))).toBe(true);
+    expect(fs.existsSync(path.join(windsurfRules, 'windsurf.md'))).toBe(false);
+    expect(fs.existsSync(path.join(windsurfRules, 'windsurf.mdc'))).toBe(true);
+  });
+});

package/scripts/hooks-system/infrastructure/orchestration/intelligent-audit.js

@@ -95,6 +95,68 @@ function summarizeRulesContent(content) {
   return firstLine.length > 0 ? firstLine : `loaded (${content.length} chars)`;
 }
 
+function buildAutoContextFrontmatter(detectedPlatforms) {
+  const platforms = Array.isArray(detectedPlatforms) ? detectedPlatforms.filter(Boolean) : [];
+  const generated = formatLocalTimestamp();
+  const platformStr = platforms.length > 0 ? platforms.join(', ') : 'none';
+  return `---\nalwaysApply: true\ndescription: Auto-generated context for detected platforms\nplatforms: ${platformStr}\ngenerated: ${generated}\n---\n\n`;
+}
+
+async function buildAutoContextContent(platformsEvidence) {
+  const loader = new DynamicRulesLoader();
+  const detectedPlatforms = ['backend', 'frontend', 'ios', 'android']
+    .filter(p => platformsEvidence && platformsEvidence[p] && platformsEvidence[p].detected);
+
+  const files = ['rulesgold.mdc', ...detectedPlatforms.map(p => loader.rulesMap[p]).filter(Boolean)];
+  const uniqueFiles = Array.from(new Set(files));
+
+  let content = buildAutoContextFrontmatter(detectedPlatforms);
+
+  for (const file of uniqueFiles) {
+    let ruleContent = null;
+    try {
+      ruleContent = await loader.loadRule(file);
+    } catch {
+      ruleContent = null;
+    }
+
+    content += `## Source: ${file}\n\n`;
+    content += ruleContent ? `${ruleContent}\n\n` : `not found\n\n`;
+    content += `---\n\n`;
+  }
+
+  return content;
+}
+
+async function writeAutoContextFiles(platformsEvidence) {
+  try {
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if (pkg && pkg.name === 'pumuki-ast-hooks') {
+        return;
+      }
+    }
+  } catch (error) {
+    process.stderr.write(`[Intelligent Audit] ⚠️  Failed to inspect package.json for auto-context skip logic (${toErrorMessage(error)})\n`);
+  }
+
+  const content = await buildAutoContextContent(platformsEvidence);
+  const targets = [
+    path.join(process.cwd(), '.cursor', 'rules', 'auto-context.mdc'),
+    path.join(process.cwd(), '.windsurf', 'rules', 'auto-context.mdc')
+  ];
+
+  for (const target of targets) {
+    try {
+      await fs.promises.mkdir(path.dirname(target), { recursive: true });
+      await fs.promises.writeFile(target, content, 'utf-8');
+    } catch (error) {
+      process.stderr.write(`[Intelligent Audit] ⚠️  Failed to write auto-context: ${target} (${toErrorMessage(error)})\n`);
+    }
+  }
+}
+
 async function buildRulesReadEvidence(platformsEvidence) {
   const loader = new DynamicRulesLoader();
   const entries = [];
@@ -158,6 +220,21 @@ function formatLocalTimestamp(date = new Date()) {
   return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}${sign}${offsetHours}:${offsetMins}`;
 }
 
+function normalizePathForMatch(value) {
+  const s = String(value || '');
+  const normalized = path.normalize(s).replace(/\\/g, '/');
+  return normalized;
+}
+
+function toRepoRelativePath(filePath) {
+  const normalized = normalizePathForMatch(filePath);
+  const cwd = normalizePathForMatch(process.cwd());
+  if (normalized.startsWith(cwd + '/')) {
+    return normalized.slice(cwd.length + 1);
+  }
+  return normalized;
+}
+
 function resolveAuditTmpDir() {
   const configured = (env.get('AUDIT_TMP', '') || '').trim();
   if (configured.length > 0) {
@@ -189,9 +266,23 @@ async function runIntelligentAudit() {
       violationsForEvidence = rawViolations;
     } else {
       const stagedFiles = getStagedFiles();
-      const stagedViolations = rawViolations.filter(v =>
-        stagedFiles.some(sf => v.filePath && v.filePath.includes(sf))
-      );
+      const stagedSet = new Set((Array.isArray(stagedFiles) ? stagedFiles : []).map(toRepoRelativePath));
+
+      const stagedViolations = rawViolations.filter(v => {
+        const violationPath = toRepoRelativePath(v.filePath || v.file || '');
+        if (!violationPath) {
+          return false;
+        }
+        if (stagedSet.has(violationPath)) {
+          return true;
+        }
+        for (const sf of stagedSet) {
+          if (sf && (violationPath === sf || violationPath.endsWith('/' + sf) || violationPath.includes('/' + sf))) {
+            return true;
+          }
+        }
+        return false;
+      });
 
       console.log(`[Intelligent Audit] Gate scope: STAGING (${stagedFiles.length} files)`);
       console.log(`[Intelligent Audit] Filtered to ${stagedViolations.length} violations in staged files`);
@@ -440,6 +531,8 @@ async function updateAIEvidence(violations, gateResult, tokenUsage) {
     const platformsEvidence = buildPlatformsEvidence(stagedFiles, violations);
     const rulesRead = await buildRulesReadEvidence(platformsEvidence);
 
+    await writeAutoContextFiles(platformsEvidence);
+
     evidence.rules_read = rulesRead.entries;
     evidence.rules_read_flags = rulesRead.legacyFlags;
 

package/scripts/hooks-system/infrastructure/severity/severity-evaluator.js

@@ -9,6 +9,20 @@ const RecommendationGenerator = require('./generators/RecommendationGenerator');
 const ContextMultiplier = require('./scorers/ContextMultiplier');
 const SeverityMapper = require('./mappers/SeverityMapper');
 
+function applySeverityFloor(originalSeverity, evaluatedSeverity) {
+  const order = {
+    LOW: 1,
+    MEDIUM: 2,
+    HIGH: 3,
+    CRITICAL: 4
+  };
+
+  const original = order[String(originalSeverity || '').toUpperCase()] || order.MEDIUM;
+  const evaluated = order[String(evaluatedSeverity || '').toUpperCase()] || original;
+
+  return evaluated >= original ? String(evaluatedSeverity || originalSeverity || 'MEDIUM').toUpperCase() : String(originalSeverity).toUpperCase();
+}
+
 /**
  * Main severity evaluator
  * Analyzes violations across 4 dimensions: Security, Performance, Stability, Maintainability
@@ -98,10 +112,13 @@ function evaluateViolations(violations) {
   return violations.map(violation => {
     const evaluation = evaluator.evaluate(violation);
 
+    const baseSeverity = violation.severity;
+    const finalSeverity = applySeverityFloor(baseSeverity, evaluation.severity);
+
     return {
       ...violation,
       originalSeverity: violation.severity,
-      severity: evaluation.severity,
+      severity: finalSeverity,
       severityScore: evaluation.score,
       baseScore: evaluation.baseScore,
       impactBreakdown: evaluation.breakdown,