@rigour-labs/core 2.9.4 → 2.10.0

package/dist/index.js

@@ -7,3 +7,7 @@ export * from './types/fix-packet.js';
 export { Gate } from './gates/base.js';
 export { RetryLoopBreakerGate } from './gates/retry-loop-breaker.js';
 export * from './utils/logger.js';
+// Pattern Index is intentionally NOT exported here to prevent
+// native dependency issues (sharp/transformers) from leaking into 
+// non-AI parts of the system. 
+// Import from @rigour-labs/core/pattern-index instead.

package/dist/pattern-index/embeddings.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Semantic Embedding Service
+ *
+ * Uses Transformers.js for local vector embeddings.
+ */
+/**
+ * Generate an embedding for a piece of text.
+ */
+export declare function generateEmbedding(text: string): Promise<number[]>;
+/**
+ * Calculate cosine similarity between two vectors.
+ */
+export declare function cosineSimilarity(v1: number[], v2: number[]): number;
+/**
+ * Perform semantic search against a list of embeddings.
+ */
+export declare function semanticSearch(queryVector: number[], entries: {
+    embedding?: number[];
+}[]): number[];

package/dist/pattern-index/embeddings.js

@@ -0,0 +1,78 @@
+/**
+ * Semantic Embedding Service
+ *
+ * Uses Transformers.js for local vector embeddings.
+ */
+/**
+ * Singleton for the embedding pipeline to avoid re-loading the model.
+ */
+let embeddingPipeline = null;
+/**
+ * Get or initialize the embedding pipeline.
+ */
+async function getPipeline() {
+    // Definitive bypass for tests to avoid native 'sharp' dependency issues
+    if (process.env.VITEST) {
+        return async (text) => {
+            const vector = new Array(384).fill(0);
+            for (let i = 0; i < Math.min(text.length, 384); i++) {
+                vector[i] = text.charCodeAt(i) / 255;
+            }
+            return { data: new Float32Array(vector) };
+        };
+    }
+    if (!embeddingPipeline) {
+        try {
+            // Dynamic import to isolate native dependency issues (like sharp)
+            const { pipeline } = await import('@xenova/transformers');
+            // Using a compact but high-quality model for local embeddings
+            embeddingPipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+        }
+        catch (error) {
+            console.error('Failed to initialize embedding pipeline:', error);
+            throw error;
+        }
+    }
+    return embeddingPipeline;
+}
+/**
+ * Generate an embedding for a piece of text.
+ */
+export async function generateEmbedding(text) {
+    try {
+        const extractor = await getPipeline();
+        const output = await extractor(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    catch (error) {
+        console.warn('Semantic reasoning disabled: Embedding generation failed.', error);
+        return [];
+    }
+}
+/**
+ * Calculate cosine similarity between two vectors.
+ */
+export function cosineSimilarity(v1, v2) {
+    if (!v1 || !v2 || v1.length !== v2.length || v1.length === 0)
+        return 0;
+    let dotProduct = 0;
+    let norm1 = 0;
+    let norm2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+        dotProduct += v1[i] * v2[i];
+        norm1 += v1[i] * v1[i];
+        norm2 += v2[i] * v2[i];
+    }
+    const denominator = Math.sqrt(norm1) * Math.sqrt(norm2);
+    return denominator === 0 ? 0 : dotProduct / denominator;
+}
+/**
+ * Perform semantic search against a list of embeddings.
+ */
+export function semanticSearch(queryVector, entries) {
+    return entries.map(entry => {
+        if (!entry.embedding)
+            return 0;
+        return cosineSimilarity(queryVector, entry.embedding);
+    });
+}

package/dist/pattern-index/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pattern Index - Main Export
+ *
+ * This is the public API for the Pattern Index system.
+ */
+export type { PatternType, PatternEntry, PatternIndex, PatternIndexConfig, PatternIndexStats, IndexedFile, PatternMatchResult, PatternMatch, PatternOverride, StalenessResult, StalenessIssue, DeprecationEntry } from './types.js';
+export { PatternIndexer, savePatternIndex, loadPatternIndex, getDefaultIndexPath } from './indexer.js';
+export { PatternMatcher, checkPatternDuplicate, type MatcherConfig } from './matcher.js';
+export { StalenessDetector, checkCodeStaleness } from './staleness.js';
+export { SecurityDetector } from './security.js';
+export { OverrideManager, loadConfigOverrides } from './overrides.js';

package/dist/pattern-index/index.js

@@ -0,0 +1,15 @@
+/**
+ * Pattern Index - Main Export
+ *
+ * This is the public API for the Pattern Index system.
+ */
+// Indexer
+export { PatternIndexer, savePatternIndex, loadPatternIndex, getDefaultIndexPath } from './indexer.js';
+// Matcher
+export { PatternMatcher, checkPatternDuplicate } from './matcher.js';
+// Staleness Detection
+export { StalenessDetector, checkCodeStaleness } from './staleness.js';
+// Security Detection
+export { SecurityDetector } from './security.js';
+// Override Management
+export { OverrideManager, loadConfigOverrides } from './overrides.js';

package/dist/pattern-index/indexer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Pattern Indexer
+ *
+ * Scans the codebase and extracts patterns using AST parsing.
+ * This is the core engine of the Pattern Index system.
+ */
+import type { PatternIndex, PatternIndexConfig } from './types.js';
+/**
+ * Pattern Indexer class.
+ * Responsible for scanning and indexing code patterns.
+ */
+export declare class PatternIndexer {
+    private config;
+    private rootDir;
+    constructor(rootDir: string, config?: Partial<PatternIndexConfig>);
+    buildIndex(): Promise<PatternIndex>;
+    /**
+     * Incremental index update - only reindex changed files.
+     */
+    updateIndex(existingIndex: PatternIndex): Promise<PatternIndex>;
+    /**
+     * Find all files to index based on configuration.
+     */
+    private findFiles;
+    /**
+     * Extract patterns from a single file using TypeScript AST.
+     */
+    private extractPatterns;
+    /**
+     * Convert an AST node to a PatternEntry if applicable.
+     */
+    private nodeToPattern;
+    /**
+     * Detect the specific type of a function based on naming conventions.
+     */
+    private detectFunctionType;
+    /**
+     * Detect the specific type of a class.
+     */
+    private detectClassType;
+    /**
+     * Check if a node contains JSX.
+     */
+    private containsJSX;
+    /**
+     * Get function signature.
+     */
+    private getFunctionSignature;
+    /**
+     * Get arrow function signature.
+     */
+    private getArrowFunctionSignature;
+    /**
+     * Get class signature.
+     */
+    private getClassSignature;
+    /**
+     * Get interface signature.
+     */
+    private getInterfaceSignature;
+    /**
+     * Extract JSDoc description from a node.
+     */
+    private getJSDocDescription;
+    /**
+     * Check if a node is exported.
+     */
+    private isExported;
+    /**
+     * Extract keywords from a name for semantic matching.
+     */
+    private extractKeywords;
+    /**
+     * Create a PatternEntry with computed fields.
+     */
+    private createPatternEntry;
+    /**
+     * Get the TypeScript ScriptKind for a file.
+     */
+    private getScriptKind;
+    /**
+     * Calculate index statistics.
+     */
+    private calculateStats;
+    /**
+     * Hash content using SHA-256.
+     */
+    private hashContent;
+}
+/**
+ * Save a pattern index to disk.
+ */
+export declare function savePatternIndex(index: PatternIndex, outputPath: string): Promise<void>;
+/**
+ * Load a pattern index from disk.
+ */
+export declare function loadPatternIndex(indexPath: string): Promise<PatternIndex | null>;
+/**
+ * Get the default index path for a project.
+ */
+export declare function getDefaultIndexPath(rootDir: string): string;