pumuki-ast-hooks 5.5.36 → 5.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.36",
+  "version": "5.5.38",
   "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/infrastructure/orchestration/__tests__/intelligent-audit.spec.js

@@ -23,7 +23,15 @@ describe('AI_EVIDENCE.json structure validation', () => {
       question_3_clean_architecture: 'Verify that the code follows Clean Architecture and SOLID principles',
       last_answered: new Date().toISOString()
     },
-    rules_read: {
+    rules_read: [
+      {
+        file: 'rulesgold.mdc',
+        verified: true,
+        summary: 'loaded (example)',
+        path: '/tmp/rulesgold.mdc'
+      }
+    ],
+    rules_read_flags: {
       backend: true,
       frontend: false,
       ios: false,
@@ -79,15 +87,25 @@ describe('AI_EVIDENCE.json structure validation', () => {
     expect(evidence.protocol_3_questions.last_answered).toBeDefined();
   });
 
-  it('should have rules_read field tracking all platforms', () => {
+  it('should have rules_read field with rule load evidence entries', () => {
     const evidence = createMockEvidence();
     expect(evidence.rules_read).toBeDefined();
-    expect(evidence.rules_read.backend).toBe(true);
-    expect(evidence.rules_read.frontend).toBe(false);
-    expect(evidence.rules_read.ios).toBe(false);
-    expect(evidence.rules_read.android).toBe(false);
-    expect(evidence.rules_read.gold).toBe(true);
-    expect(evidence.rules_read.last_checked).toBeDefined();
+    expect(Array.isArray(evidence.rules_read)).toBe(true);
+    expect(evidence.rules_read.length).toBeGreaterThan(0);
+    expect(evidence.rules_read[0]).toHaveProperty('file');
+    expect(evidence.rules_read[0]).toHaveProperty('verified');
+    expect(evidence.rules_read[0]).toHaveProperty('summary');
+  });
+
+  it('should have rules_read_flags legacy field tracking platform flags', () => {
+    const evidence = createMockEvidence();
+    expect(evidence.rules_read_flags).toBeDefined();
+    expect(evidence.rules_read_flags.backend).toBe(true);
+    expect(evidence.rules_read_flags.frontend).toBe(false);
+    expect(evidence.rules_read_flags.ios).toBe(false);
+    expect(evidence.rules_read_flags.android).toBe(false);
+    expect(evidence.rules_read_flags.gold).toBe(true);
+    expect(evidence.rules_read_flags.last_checked).toBeDefined();
   });
 
   it('should have current_context field with branch and file info', () => {

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

@@ -9,6 +9,7 @@ const { TokenManager } = require('../utils/token-manager');
 const { toErrorMessage } = require('../utils/error-utils');
 const fs = require('fs');
 const path = require('path');
+const DynamicRulesLoader = require('../../application/services/DynamicRulesLoader');
 
 function deriveCategoryFromRuleId(ruleId) {
   if (!ruleId || typeof ruleId !== 'string') return 'unknown';
@@ -24,6 +25,183 @@ function deriveCategoryFromRuleId(ruleId) {
   return parts[0] || 'unknown';
 }
 
+function detectPlatformsFromStagedFiles(stagedFiles) {
+  const platforms = new Set();
+  const files = Array.isArray(stagedFiles) ? stagedFiles : [];
+
+  files.forEach(filePath => {
+    const lowerPath = String(filePath || '').toLowerCase();
+
+    if (lowerPath.includes('apps/backend/') || lowerPath.includes('/services/') || lowerPath.includes('services/') || lowerPath.includes('/functions/') || lowerPath.includes('functions/')) {
+      platforms.add('backend');
+    }
+    if (lowerPath.includes('apps/web-app/') || lowerPath.includes('apps/admin') || lowerPath.includes('apps/frontend/') || lowerPath.includes('frontend/')) {
+      platforms.add('frontend');
+    }
+    if (lowerPath.includes('apps/ios/') || lowerPath.endsWith('.swift')) {
+      platforms.add('ios');
+    }
+    if (lowerPath.includes('apps/android/') || lowerPath.endsWith('.kt') || lowerPath.endsWith('.kts') || lowerPath.endsWith('.java')) {
+      platforms.add('android');
+    }
+  });
+
+  return platforms;
+}
+
+function countViolationsByPlatform(violations) {
+  const counts = { backend: 0, frontend: 0, ios: 0, android: 0 };
+  const list = Array.isArray(violations) ? violations : [];
+
+  list.forEach(v => {
+    const ruleId = v.ruleId || v.rule || 'unknown';
+    const category = String(v.category || deriveCategoryFromRuleId(ruleId) || '').toLowerCase();
+    const platform = category.split('.')[0];
+    if (counts[platform] !== undefined) {
+      counts[platform] += 1;
+    }
+  });
+
+  return counts;
+}
+
+function buildPlatformsEvidence(stagedFiles, violations) {
+  const stagedDetected = detectPlatformsFromStagedFiles(stagedFiles);
+  const violationCounts = countViolationsByPlatform(violations);
+
+  const platforms = ['backend', 'frontend', 'ios', 'android'];
+  const result = {};
+
+  platforms.forEach(p => {
+    const violationsCount = violationCounts[p] || 0;
+    result[p] = {
+      detected: stagedDetected.has(p) || violationsCount > 0,
+      violations: violationsCount
+    };
+  });
+
+  return result;
+}
+
+function summarizeRulesContent(content) {
+  if (!content || typeof content !== 'string') {
+    return 'not found';
+  }
+  const firstNonEmpty = content
+    .split('\n')
+    .map(l => l.trim())
+    .find(l => l.length > 0);
+  const firstLine = firstNonEmpty ? firstNonEmpty.slice(0, 140) : '';
+  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 = [];
+
+  const detectedPlatforms = ['backend', 'frontend', 'ios', 'android']
+    .filter(p => platformsEvidence && platformsEvidence[p] && platformsEvidence[p].detected);
+
+  const uniqueFiles = ['rulesgold.mdc', ...detectedPlatforms.map(p => loader.rulesMap[p]).filter(Boolean)];
+
+  for (const file of uniqueFiles) {
+    let verified = false;
+    let summary = 'not found';
+    let resolvedPath = null;
+
+    try {
+      const content = await loader.loadRule(file);
+      verified = Boolean(content);
+      summary = summarizeRulesContent(content);
+      const cached = loader.cache && loader.cache.rules ? loader.cache.rules.get(file) : null;
+      resolvedPath = cached && cached.fullPath ? cached.fullPath : null;
+    } catch (error) {
+      summary = `error: ${toErrorMessage(error)}`;
+    }
+
+    entries.push({
+      file,
+      verified,
+      summary,
+      path: resolvedPath
+    });
+  }
+
+  return {
+    entries,
+    legacyFlags: {
+      backend: detectedPlatforms.includes('backend'),
+      frontend: detectedPlatforms.includes('frontend'),
+      ios: detectedPlatforms.includes('ios'),
+      android: detectedPlatforms.includes('android'),
+      gold: true,
+      last_checked: formatLocalTimestamp()
+    }
+  };
+}
+
 function formatLocalTimestamp(date = new Date()) {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, '0');
@@ -90,7 +268,7 @@ async function runIntelligentAudit() {
       const gateResult = { passed: true, exitCode: 0, blockedBy: null };
       const tokenManager = new TokenManager();
       const tokenUsage = tokenManager.estimate(enhancedAll, {});
-      updateAIEvidence(enhancedAll, gateResult, tokenUsage);
+      await updateAIEvidence(enhancedAll, gateResult, tokenUsage);
       process.exit(0);
     }
 
@@ -136,7 +314,7 @@ async function runIntelligentAudit() {
 
     tokenManager.record(tokenUsage);
 
-    updateAIEvidence(enhancedViolations, gateResult, tokenUsage);
+    await updateAIEvidence(enhancedViolations, gateResult, tokenUsage);
 
     saveEnhancedViolations(enhancedViolations);
 
@@ -201,7 +379,7 @@ function saveEnhancedViolations(violations) {
   fs.writeFileSync(outputPath, JSON.stringify(enhanced, null, 2));
 }
 
-function updateAIEvidence(violations, gateResult, tokenUsage) {
+async function updateAIEvidence(violations, gateResult, tokenUsage) {
   const evidencePath = '.AI_EVIDENCE.json';
 
   if (!fs.existsSync(evidencePath)) {
@@ -320,14 +498,14 @@ function updateAIEvidence(violations, gateResult, tokenUsage) {
       last_answered: formatLocalTimestamp()
     };
 
-    evidence.rules_read = {
-      backend: true,
-      frontend: false,
-      ios: false,
-      android: false,
-      gold: true,
-      last_checked: formatLocalTimestamp()
-    };
+    const stagedFiles = getStagedFiles();
+    const platformsEvidence = buildPlatformsEvidence(stagedFiles, violations);
+    const rulesRead = await buildRulesReadEvidence(platformsEvidence);
+
+    await writeAutoContextFiles(platformsEvidence);
+
+    evidence.rules_read = rulesRead.entries;
+    evidence.rules_read_flags = rulesRead.legacyFlags;
 
     evidence.current_context = {
       working_on: env.get('AUTO_EVIDENCE_SUMMARY', 'AST Intelligence Analysis'),
@@ -337,12 +515,7 @@ function updateAIEvidence(violations, gateResult, tokenUsage) {
       timestamp: formatLocalTimestamp()
     };
 
-    evidence.platforms = {
-      backend: { detected: true, violations: violations.filter(v => v.category && v.category.includes('backend')).length },
-      frontend: { detected: false, violations: 0 },
-      ios: { detected: false, violations: 0 },
-      android: { detected: false, violations: 0 }
-    };
+    evidence.platforms = platformsEvidence;
 
     evidence.session_id = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;