argusqa-os 9.5.1 → 9.5.5

package/src/orchestration/orchestrator.js

@@ -1,5 +1,5 @@
 /**
- * Argus Orchestrator (v9.3.0)
+ * Argus Orchestrator
  *
  * Per-route crawl loop: cheap×2 flakiness pass + expensive×1 pass.
  * Extracted from crawl-and-report.js god object.
@@ -15,7 +15,6 @@ import 'dotenv/config';
 import { routes, config, auth, flows, apiContracts, severityOverrides, codebase, autoDiscover, thresholds } from '../config/targets.js';
 import { discoverRoutes }                                                from '../utils/route-discoverer.js';
 import { analyzeCodebase, detectDeadRoutes, INTERNAL_LINKS_SCRIPT }     from '../utils/codebase-analyzer.js';
-import { CSS_ANALYSIS_SCRIPT, parseCssAnalysisResult }                  from '../utils/css-analyzer.js';
 import { SEO_ANALYSIS_SCRIPT, parseSeoAnalysisResult }                  from '../utils/seo-analyzer.js';
 import { SECURITY_ANALYSIS_SCRIPT, parseSecurityAnalysisResult, analyzeSecurityConsole, analyzeSecurityNetwork } from '../utils/security-analyzer.js';
 import { CONTENT_ANALYSIS_SCRIPT, parseContentAnalysisResult }          from '../utils/content-analyzer.js';
@@ -26,6 +25,7 @@ import { analyzeApiFrequency }                                           from '.
 import { slugify }                                                       from '../utils/slug.js';
 import { unwrapEval, createMcpClient }                                   from '../utils/mcp-client.js';
 import { CdpBrowserAdapter }                                             from '../adapters/browser.js';
+import { getFigmaFrame }                                                 from '../adapters/figma.js';
 import { chunkArray }                                                    from '../utils/parallel-crawler.js';
 import { validateApiContracts }                                          from '../utils/contract-validator.js';
 import { checkLighthouse }                                               from '../utils/lighthouse-checker.js';
@@ -33,13 +33,18 @@ import { parseIssues }                                                   from '.
 import { parseNetworkTiming }                                            from '../utils/network-timing-analyzer.js';
 
 // Side-effect imports: each module calls registerExpensive() at load time.
-// lighthouse-checker.js also self-registers via its direct named import above (line 31).
+// lighthouse-checker.js also self-registers via its direct named import above.
 // Order below controls iteration order in crawlAndAnalyzeRoute — must match original call order.
+import '../utils/css-analyzer.js';
 import '../utils/responsive-analyzer.js';
 import '../utils/memory-analyzer.js';
 import '../utils/hover-analyzer.js';
 import '../utils/snapshot-analyzer.js';
 import '../utils/keyboard-analyzer.js';
+import '../utils/theme-analyzer.js';
+import '../utils/design-fidelity-analyzer.js';
+import '../utils/web-vitals-analyzer.js';
+import '../utils/visual-diff-analyzer.js';
 
 import { getExpensive }          from '../registry.js';
 import { deduplicateFindings as deduplicateErrors } from './report-processor.js';
@@ -54,6 +59,7 @@ const logger = childLogger('orchestrator');
 const __dirname   = path.dirname(fileURLToPath(import.meta.url));
 const BASE_URL    = process.env.TARGET_DEV_URL ?? 'http://localhost:3000';
 const OUTPUT_DIR  = path.resolve(__dirname, '../../', config.outputDir);
+const LIGHTHOUSE_TIMEOUT_MS = parseInt(process.env.ARGUS_LIGHTHOUSE_TIMEOUT ?? '120000', 10);
 
 // Thresholds for perf budgets and network analysis are centralized in targets.js.
 
@@ -362,7 +368,6 @@ function analyzeNetworkPerformance(perfEntries, pageUrl) {
 
 async function checkPerformanceBudgets(browser, url) {
   const violations = [];
-  const LIGHTHOUSE_TIMEOUT_MS = parseInt(process.env.ARGUS_LIGHTHOUSE_TIMEOUT ?? '120000', 10);
 
   try {
     await browser.startTrace();
@@ -397,7 +402,6 @@ async function checkPerformanceBudgets(browser, url) {
     logger.warn(`[ARGUS] Performance trace skipped for ${url}: ${err.message}`);
   }
 
-  void LIGHTHOUSE_TIMEOUT_MS; // referenced only here to prevent unused-var lint
   return violations;
 }
 
@@ -724,15 +728,7 @@ export async function crawlRouteCheap(route, baseUrl, mcp) {
     }
   } catch { /* URL parse failure */ }
 
-  // 10. CSS analysis
-  try {
-    const cssRaw = await browser.evaluate(CSS_ANALYSIS_SCRIPT);
-    result.errors.push(...parseCssAnalysisResult(unwrapEval(cssRaw), url));
-  } catch (err) {
-    logger.warn(`[ARGUS] CSS analysis skipped for ${url}: ${err.message}`);
-  }
-
-  // 11. Deduplicate within this cheap run
+  // 10. Deduplicate within this cheap run
   result.errors = deduplicateErrors(result.errors);
 
   // 12. Screenshot
@@ -805,8 +801,14 @@ export async function crawlRouteExpensive(route, baseUrl, mcp) {
   // Performance budget check
   errors.push(...(await checkPerformanceBudgets(browser, url)));
 
-  // Full Lighthouse audit
-  errors.push(...(await checkLighthouse(browser, url)));
+  // Full Lighthouse audit (capped at LIGHTHOUSE_TIMEOUT_MS to prevent indefinite hang)
+  errors.push(...(await Promise.race([
+    checkLighthouse(browser, url),
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`Lighthouse timed out after ${LIGHTHOUSE_TIMEOUT_MS}ms`)), LIGHTHOUSE_TIMEOUT_MS)),
+  ]).catch(err => {
+    logger.warn(`[ARGUS] Lighthouse skipped for ${url}: ${err.message}`);
+    return [];
+  })));
 
   // Broken internal link detection
   try {
@@ -880,24 +882,34 @@ async function crawlAndAnalyzeRoute(route, targetBaseUrl, mcp, sessionFile) {
       await refreshSession(browser, auth, targetBaseUrl);
       await restoreSession(browser, targetBaseUrl, sessionFile);
     } catch (err) {
-      logger.warn(`[ARGUS] Auth: session restore skipped for ${route.name}: ${err.message}`);
+      logger.warn(`[ARGUS] Auth: session restore skipped for ${route.name} (${route.path}): ${err.message}`);
     }
   }
 
   // Cheap pass × 2 → merge for flakiness
-  logger.info(`[ARGUS] ${route.name}: cheap run 1/2...`);
+  logger.info(`[ARGUS] ${route.name} (${route.path}): cheap run 1/2...`);
   const cheapRun1 = await startSpan('argus.crawl_route', { url, critical: String(!!route.critical), pass: 'cheap_1' }, () => crawlRouteCheap(route, targetBaseUrl, mcp));
-  logger.info(`[ARGUS] ${route.name}: cheap run 2/2 (flakiness check)...`);
+  logger.info(`[ARGUS] ${route.name} (${route.path}): cheap run 2/2 (flakiness check)...`);
   const cheapRun2 = await startSpan('argus.crawl_route', { url, critical: String(!!route.critical), pass: 'cheap_2' }, () => crawlRouteCheap(route, targetBaseUrl, mcp));
   const result    = mergeRunResults(cheapRun1, cheapRun2);
 
   // Expensive pass × 1
-  logger.info(`[ARGUS] ${route.name}: expensive analyzers (once)...`);
+  logger.info(`[ARGUS] ${route.name} (${route.path}): expensive analyzers (once)...`);
   const expensiveErrors = await startSpan('argus.crawl_route', { url, critical: String(!!route.critical), pass: 'expensive' }, () => crawlRouteExpensive(route, targetBaseUrl, mcp));
   result.errors.push(...expensiveErrors);
   result.errors = deduplicateErrors(result.errors);
 
-  // Post-crawl expensive analyzers via registry (responsive, memory, hover, snapshot, keyboard)
+  // D9: Pre-fetch Figma design tokens when route specifies a figmaFrameUrl.
+  // Attaches figmaData to the route object so design-fidelity-analyzer can consume it.
+  if (route.figmaFrameUrl && !route.figmaData) {
+    try {
+      route.figmaData = await getFigmaFrame(route.figmaFrameUrl);
+    } catch (err) {
+      logger.warn(`[ARGUS] D9: Figma fetch failed for ${route.name} (${route.path}): ${err.message}`);
+    }
+  }
+
+  // Post-crawl expensive analyzers via registry (css, responsive, memory, hover, snapshot, keyboard, theme, design-fidelity)
   for (const { name, analyze } of getExpensive()) {
     if (name === 'lighthouse') continue; // runs inside crawlRouteExpensive
     try {
@@ -923,7 +935,7 @@ async function crawlAndAnalyzeRoute(route, targetBaseUrl, mcp, sessionFile) {
         if (Object.keys(screenshotPaths).length > 0) result.responsiveScreenshots = screenshotPaths;
       }
     } catch (err) {
-      logger.warn(`[ARGUS] ${name} skipped for ${route.name}: ${err.message}`);
+      logger.warn(`[ARGUS] ${name} skipped for ${route.name} (${route.path}): ${err.message}`);
     }
   }
 
@@ -955,7 +967,7 @@ async function crawlShardWithClient(shard, targetBaseUrl, mcp, sessionFile) {
     const result = await crawlAndAnalyzeRoute(route, targetBaseUrl, mcp, sessionFile);
     const flakyCount = result.errors.filter(e => e.flaky).length;
     if (flakyCount > 0) {
-      logger.info(`[ARGUS/parallel] ${route.name}: ${flakyCount} finding(s) downgraded to info (flaky)`);
+      logger.info(`[ARGUS/parallel] ${route.name} (${route.path}): ${flakyCount} finding(s) downgraded to info (flaky)`);
     }
     results.push(result);
   }
@@ -1060,7 +1072,7 @@ export async function runCrawl(mcp, routeOverrides = null, baseUrlOverride = nul
 
       const flakyCount = result.errors.filter(e => e.flaky).length;
       if (flakyCount > 0) {
-        logger.info(`[ARGUS] ${route.name}: ${flakyCount} finding(s) downgraded to info (flaky — appeared in only one cheap run)`);
+        logger.info(`[ARGUS] ${route.name} (${route.path}): ${flakyCount} finding(s) downgraded to info (flaky — appeared in only one cheap run)`);
       }
 
       report.routes.push(result);

package/src/orchestration/report-processor.js

@@ -1,5 +1,5 @@
 /**
- * Argus Report Processor (v9.1.3)
+ * Argus Report Processor
  *
  * Post-crawl pipeline: dedup → severity overrides → summary rebuild →
  * baseline load/apply/save → trend append → JSON write.

package/src/orchestration/slack-notifier.js

@@ -54,7 +54,8 @@ async function slackPostWithBackoff(args) {
       const isRateLimit = err.code === 'slack_webapi_rate_limited'
         || err.message?.toLowerCase().includes('ratelimited');
       if (!isRateLimit || attempt === SLACK_RATE_LIMIT_RETRIES - 1) throw err;
-      const retryAfterMs = (err.retryAfter ?? 1) * 1000;
+      const jitter = Math.floor(Math.random() * 1000);
+      const retryAfterMs = (err.retryAfter ?? 1) * 1000 + jitter;
       logger.warn(`[ARGUS] Slack rate limited — retrying in ${retryAfterMs}ms (attempt ${attempt + 1})`);
       await new Promise(r => setTimeout(r, retryAfterMs));
     }

package/src/registry.js

@@ -1,5 +1,5 @@
 /**
- * Argus Analyzer Plugin Registry (v9.1.2)
+ * Argus Analyzer Plugin Registry
  *
  * Analyzers self-register at module load time by calling registerCheap()
  * or registerExpensive(). The orchestrator iterates getCheap() / getExpensive()

package/src/utils/css-analyzer.js

@@ -26,6 +26,8 @@
  */
 
 import { childLogger } from './logger.js';
+import { registerExpensive } from '../registry.js';
+import { unwrapEval } from './mcp-client.js';
 
 const logger = childLogger('css-analyzer');
 
@@ -405,3 +407,8 @@ export function parseCssAnalysisResult(rawResult, url) {
 
   return bugs;
 }
+
+registerExpensive({ name: 'css', analyze: async (browser, url) => {
+  const cssRaw = await browser.evaluate(CSS_ANALYSIS_SCRIPT);
+  return parseCssAnalysisResult(unwrapEval(cssRaw), url);
+} });