@rigour-labs/core 2.21.1 → 2.22.0

package/src/gates/runner.ts

@@ -1,5 +1,5 @@
 import { Gate } from './base.js';
-import { Failure, Config, Report, Status } from '../types/index.js';
+import { Failure, Config, Report, Status, Severity, SEVERITY_WEIGHTS } from '../types/index.js';
 import { FileGate } from './file.js';
 import { ContentGate } from './content.js';
 import { StructureGate } from './structure.js';
@@ -14,6 +14,10 @@ import { RetryLoopBreakerGate } from './retry-loop-breaker.js';
 import { AgentTeamGate } from './agent-team.js';
 import { CheckpointGate } from './checkpoint.js';
 import { SecurityPatternsGate } from './security-patterns.js';
+import { DuplicationDriftGate } from './duplication-drift.js';
+import { HallucinatedImportsGate } from './hallucinated-imports.js';
+import { InconsistentErrorHandlingGate } from './inconsistent-error-handling.js';
+import { ContextWindowArtifactsGate } from './context-window-artifacts.js';
 import { execa } from 'execa';
 import { Logger } from '../utils/logger.js';
 
@@ -66,6 +70,23 @@ export class GateRunner {
             this.gates.push(new SecurityPatternsGate(this.config.gates.security));
         }
 
+        // v2.16+ AI-Native Drift Detection Gates (enabled by default)
+        if (this.config.gates.duplication_drift?.enabled !== false) {
+            this.gates.push(new DuplicationDriftGate(this.config.gates.duplication_drift));
+        }
+
+        if (this.config.gates.hallucinated_imports?.enabled !== false) {
+            this.gates.push(new HallucinatedImportsGate(this.config.gates.hallucinated_imports));
+        }
+
+        if (this.config.gates.inconsistent_error_handling?.enabled !== false) {
+            this.gates.push(new InconsistentErrorHandlingGate(this.config.gates.inconsistent_error_handling));
+        }
+
+        if (this.config.gates.context_window_artifacts?.enabled !== false) {
+            this.gates.push(new ContextWindowArtifactsGate(this.config.gates.context_window_artifacts));
+        }
+
         // Environment Alignment Gate (Should be prioritized)
         if (this.config.gates.environment?.enabled) {
             this.gates.unshift(new EnvironmentGate(this.config.gates));
@@ -141,7 +162,17 @@ export class GateRunner {
         }
 
         const status: Status = failures.length > 0 ? 'FAIL' : 'PASS';
-        const score = Math.max(0, 100 - (failures.length * 5)); // Basic SME scoring logic
+
+        // Severity-weighted scoring: each failure deducts based on its severity
+        // critical=20, high=10, medium=5, low=2, info=0
+        const severityBreakdown: Record<string, number> = {};
+        let totalDeduction = 0;
+        for (const f of failures) {
+            const sev = (f.severity || 'medium') as Severity;
+            severityBreakdown[sev] = (severityBreakdown[sev] || 0) + 1;
+            totalDeduction += SEVERITY_WEIGHTS[sev] ?? 5;
+        }
+        const score = Math.max(0, 100 - totalDeduction);
 
         return {
             status,
@@ -150,6 +181,7 @@ export class GateRunner {
             stats: {
                 duration_ms: Date.now() - start,
                 score,
+                severity_breakdown: severityBreakdown,
             },
         };
     }

package/src/gates/security-patterns.ts

@@ -236,7 +236,8 @@ export class SecurityPatternsGate extends Gate {
                     `Found: "${vuln.match.slice(0, 60)}..." - Use parameterized queries/sanitization.`,
                     `Security: ${vuln.type.replace('_', ' ').toUpperCase()}`,
                     vuln.line,
-                    vuln.line
+                    vuln.line,
+                    vuln.severity
                 ));
             }
         }

package/src/pattern-index/indexer.ts

@@ -109,7 +109,8 @@ export class PatternIndexer {
 
         // Generate embeddings in parallel batches if enabled
         if (this.config.useEmbeddings && patterns.length > 0) {
-            console.log(`Generating embeddings for ${patterns.length} patterns...`);
+            // Use stderr to avoid contaminating JSON output on stdout
+            process.stderr.write(`Generating embeddings for ${patterns.length} patterns...\n`);
             for (let i = 0; i < patterns.length; i += BATCH_SIZE) {
                 const batch = patterns.slice(i, i + BATCH_SIZE);
                 await Promise.all(batch.map(async (pattern) => {

package/src/templates/index.ts

@@ -303,6 +303,32 @@ export const UNIVERSAL_CONFIG: Config = {
                 'prefer-const': false,
             },
         },
+        duplication_drift: {
+            enabled: true,
+            similarity_threshold: 0.8,
+            min_body_lines: 5,
+        },
+        hallucinated_imports: {
+            enabled: true,
+            check_relative: true,
+            check_packages: true,
+            ignore_patterns: [
+                '\\.css$', '\\.scss$', '\\.less$', '\\.svg$', '\\.png$', '\\.jpg$',
+                '\\.json$', '\\.wasm$', '\\.graphql$', '\\.gql$',
+            ],
+        },
+        inconsistent_error_handling: {
+            enabled: true,
+            max_strategies_per_type: 2,
+            min_occurrences: 3,
+            ignore_empty_catches: false,
+        },
+        context_window_artifacts: {
+            enabled: true,
+            min_file_lines: 100,
+            degradation_threshold: 0.4,
+            signals_required: 2,
+        },
     },
     output: {
         report_path: 'rigour-report.json',

package/src/types/index.ts

@@ -103,6 +103,33 @@ export const GatesSchema = z.object({
         auto_detect_tier: z.boolean().optional().default(true),
         forced_tier: z.enum(['hobby', 'startup', 'enterprise']).optional(),
     }).optional().default({}),
+    // v2.16+ AI-Native Drift Detection Gates
+    duplication_drift: z.object({
+        enabled: z.boolean().optional().default(true),
+        similarity_threshold: z.number().min(0).max(1).optional().default(0.8),
+        min_body_lines: z.number().optional().default(5),
+    }).optional().default({}),
+    hallucinated_imports: z.object({
+        enabled: z.boolean().optional().default(true),
+        check_relative: z.boolean().optional().default(true),
+        check_packages: z.boolean().optional().default(true),
+        ignore_patterns: z.array(z.string()).optional().default([
+            '\\.css$', '\\.scss$', '\\.less$', '\\.svg$', '\\.png$', '\\.jpg$',
+            '\\.json$', '\\.wasm$', '\\.graphql$', '\\.gql$',
+        ]),
+    }).optional().default({}),
+    inconsistent_error_handling: z.object({
+        enabled: z.boolean().optional().default(true),
+        max_strategies_per_type: z.number().optional().default(2),
+        min_occurrences: z.number().optional().default(3),
+        ignore_empty_catches: z.boolean().optional().default(false),
+    }).optional().default({}),
+    context_window_artifacts: z.object({
+        enabled: z.boolean().optional().default(true),
+        min_file_lines: z.number().optional().default(100),
+        degradation_threshold: z.number().min(0).max(1).optional().default(0.4),
+        signals_required: z.number().optional().default(2),
+    }).optional().default({}),
 });
 
 export const CommandsSchema = z.object({
@@ -136,10 +163,23 @@ export type RawConfig = z.input<typeof ConfigSchema>;
 export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
 export type Status = z.infer<typeof StatusSchema>;
 
+export const SeveritySchema = z.enum(['critical', 'high', 'medium', 'low', 'info']);
+export type Severity = z.infer<typeof SeveritySchema>;
+
+/** Severity weights for score calculation */
+export const SEVERITY_WEIGHTS: Record<Severity, number> = {
+    critical: 20,
+    high: 10,
+    medium: 5,
+    low: 2,
+    info: 0,
+};
+
 export const FailureSchema = z.object({
     id: z.string(),
     title: z.string(),
     details: z.string(),
+    severity: SeveritySchema.optional(),
     files: z.array(z.string()).optional(),
     line: z.number().optional(),
     endLine: z.number().optional(),
@@ -154,6 +194,7 @@ export const ReportSchema = z.object({
     stats: z.object({
         duration_ms: z.number(),
         score: z.number().optional(),
+        severity_breakdown: z.record(z.number()).optional(),
     }),
 });
 export type Report = z.infer<typeof ReportSchema>;