@rigour-labs/core 5.0.1 → 5.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "5.0.1",
+  "version": "5.1.1",
   "description": "Deterministic quality gate engine for AI-generated code. AST analysis, drift detection, and Fix Packet generation across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -57,16 +57,15 @@
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.30.1",
     "@xenova/transformers": "^2.17.2",
-    "better-sqlite3": "^11.0.0",
+    "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "5.0.1",
-    "@rigour-labs/brain-linux-arm64": "5.0.1",
-    "@rigour-labs/brain-linux-x64": "5.0.1",
-    "@rigour-labs/brain-win-x64": "5.0.1",
-    "@rigour-labs/brain-darwin-x64": "5.0.1"
+    "@rigour-labs/brain-darwin-arm64": "5.1.1",
+    "@rigour-labs/brain-darwin-x64": "5.1.1",
+    "@rigour-labs/brain-linux-arm64": "5.1.1",
+    "@rigour-labs/brain-win-x64": "5.1.1",
+    "@rigour-labs/brain-linux-x64": "5.1.1"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.12",
     "@types/fs-extra": "^11.0.4",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^25.0.3",

package/dist/gates/duplication-drift.d.ts

@@ -1,128 +0,0 @@
-/**
- * Duplication Drift Gate (v2)
- *
- * Detects when AI generates near-identical functions across files because
- * it doesn't remember what it already wrote. This is an AI-specific failure
- * mode — humans reuse via copy-paste (same file), AI re-invents (cross-file).
- *
- * v2 upgrades:
- * - tree-sitter AST node type sequences replace hand-rolled regex tokenizer
- * - Jaccard similarity on AST node multisets (structural, not textual)
- * - Catches duplicates even when every variable name is different
- * - MD5 kept as fast-path for exact matches, Jaccard runs on remaining pairs
- *
- * Detection strategy (three-pass):
- * 1. Extract function bodies, normalize text (strip comments/whitespace)
- * 2. Parse with tree-sitter → walk AST → collect node type multiset
- * 3. Generate semantic embeddings via all-MiniLM-L6-v2 (384D)
- * 4. Pass 1 (fast):     MD5 hash → exact duplicates (O(n), <10ms)
- * 5. Pass 2 (Jaccard):  AST node multiset similarity → structural near-duplicates (O(n²) bounded)
- * 6. Pass 3 (semantic):  Embedding cosine similarity → semantic duplicates (O(n²) bounded)
- * 7. Flag functions with similarity > threshold in different files
- *
- * Why AST node types > raw tokens:
- * - `getUserById(id) { return db.find(x => x.id === id) }`
- * - `fetchUser(userId) { return database.filter(u => u.id === userId)[0] }`
- * Both produce similar AST: [return_statement, call_expression, arrow_function,
- *   binary_expression, member_expression]. Variable names are invisible.
- *
- * @since v2.16.0 (original MD5)
- * @since v5.0.0  (tree-sitter AST + Jaccard)
- * @since v5.1.0  (semantic embedding Pass 3)
- */
-import { Gate, GateContext } from './base.js';
-import { Failure, Provenance } from '../types/index.js';
-export interface DuplicationDriftConfig {
-    enabled?: boolean;
-    similarity_threshold?: number;
-    semantic_threshold?: number;
-    semantic_enabled?: boolean;
-    min_body_lines?: number;
-    approved_duplications?: string[];
-}
-export declare class DuplicationDriftGate extends Gate {
-    private config;
-    private parser;
-    constructor(config?: DuplicationDriftConfig);
-    protected get provenance(): Provenance;
-    run(context: GateContext): Promise<Failure[]>;
-    /**
-     * Parse the file with tree-sitter, find function nodes that match
-     * our extracted functions (by line number), and replace their token
-     * multisets with AST node type sequences.
-     *
-     * AST node types are language-agnostic structural tokens:
-     * - if_statement, for_statement, return_statement
-     * - call_expression, member_expression, binary_expression
-     * - arrow_function, function_declaration
-     *
-     * Variable names, string literals, comments — all invisible.
-     * Only STRUCTURE matters.
-     */
-    private enrichWithASTTokens;
-    /**
-     * Walk the AST tree to find a function/method node at a given line.
-     */
-    private findFunctionNodeAtLine;
-    /**
-     * Walk an AST subtree and collect node types as a multiset.
-     *
-     * This is the core insight: two functions with different variable names
-     * but the same control flow produce the same node type multiset.
-     *
-     * Example:
-     * `function a(x) { if (x > 0) return x * 2; return 0; }`
-     * `function b(val) { if (val > 0) return val * 2; return 0; }`
-     *
-     * Both produce: {if_statement: 1, binary_expression: 2, return_statement: 2, ...}
-     * → Jaccard similarity = 1.0
-     */
-    private collectASTNodeTypes;
-    /**
-     * Fallback tokenizer when tree-sitter is not available.
-     * Uses normalized text → keyword/operator multiset.
-     */
-    private textTokenize;
-    /**
-     * Jaccard similarity on multisets.
-     * intersection = sum of min(countA, countB) for each key
-     * union = sum of max(countA, countB) for each key
-     */
-    private jaccardSimilarity;
-    private extractJSFunctions;
-    private extractPyFunctions;
-    private extractFunctionBody;
-    private normalizeBody;
-    private hash;
-    /**
-     * Generate semantic embedding text for a function.
-     * Combines function name, parameter names, and first 200 tokens of body.
-     * This captures INTENT regardless of implementation differences.
-     *
-     * Example:
-     * getUserById(id) { return db.users.find(x => x.id === id) }
-     * → "getUserById id return db users find x id id"
-     *
-     * fetchUserRecord(userId) { return database.users.filter(u => u.id === userId)[0] }
-     * → "fetchUserRecord userId return database users filter u id userId 0"
-     *
-     * These produce similar embeddings (~0.91 cosine) despite different AST.
-     */
-    private buildEmbeddingText;
-    /**
-     * Enrich functions with semantic embeddings for Pass 3.
-     * Only called for functions not already claimed by Pass 1/2.
-     * Uses generateEmbedding() from pattern-index/embeddings.ts.
-     */
-    private enrichWithEmbeddings;
-    /**
-     * Three-pass duplicate detection:
-     * Pass 1 (fast):     MD5 hash → exact duplicates (O(n))
-     * Pass 2 (Jaccard):  AST node multiset similarity → near-duplicates (O(n²) bounded)
-     * Pass 3 (semantic):  Embedding cosine similarity → semantic duplicates (O(n²) bounded)
-     *
-     * Pass 3 catches what AST Jaccard misses: same intent, different implementation.
-     * Example: .find() vs .filter()[0] — different AST nodes, same semantic meaning.
-     */
-    private findDuplicateGroups;
-}