pumuki-ast-hooks 5.5.35 → 5.5.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.35",
+  "version": "5.5.37",
   "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/bin/check-version.js

@@ -104,8 +104,8 @@ function getInstalledVersion() {
 
 function getLatestVersion() {
   try {
-    // Try npm view
-    const output = execSync('npm view @pumuki/ast-intelligence-hooks version', {
+    // Try npm view (correct package name: pumuki-ast-hooks)
+    const output = execSync('npm view pumuki-ast-hooks version', {
       encoding: 'utf-8',
       stdio: ['ignore', 'pipe', 'ignore'],
       timeout: 5000

package/scripts/hooks-system/bin/gitflow-release.js

@@ -112,11 +112,10 @@ function step2_syncDevelop() {
     log(COLORS.cyan, '═══════════════════════════════════════════════════════════════\n');
 
     log(COLORS.blue, 'Fetching from origin...');
-    exec('git fetch origin', { silent: true });
+    exec('git fetch origin');
 
     log(COLORS.blue, 'Pulling latest changes from develop...');
-    exec('git pull origin develop', { silent: true });
-
+    exec('git pull --ff-only origin develop');
     log(COLORS.green, '✅ Develop synced');
 }
 
@@ -125,13 +124,19 @@ function step3_syncMain() {
     log(COLORS.cyan, '🔄 Step 3: Sync Main');
     log(COLORS.cyan, '═══════════════════════════════════════════════════════════════\n');
 
+    const current = getCurrentBranch();
+
     log(COLORS.blue, 'Fetching from origin...');
-    exec('git fetch origin', { silent: true });
+    exec('git fetch origin');
 
     log(COLORS.blue, 'Pulling latest changes from main...');
-    exec('git pull origin main', { silent: true });
-
+    exec('git checkout main');
+    exec('git pull --ff-only origin main');
     log(COLORS.green, '✅ Main synced');
+
+    if (current && current !== 'main') {
+        exec(`git checkout ${current}`);
+    }
 }
 
 function step4_createReleasePR(prTitle, prBody) {

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,121 @@ 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)`;
+}
+
+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 +206,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 +252,7 @@ async function runIntelligentAudit() {
 
     tokenManager.record(tokenUsage);
 
-    updateAIEvidence(enhancedViolations, gateResult, tokenUsage);
+    await updateAIEvidence(enhancedViolations, gateResult, tokenUsage);
 
     saveEnhancedViolations(enhancedViolations);
 
@@ -201,7 +317,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 +436,12 @@ 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);
+
+    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 +451,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)}`;