@rigour-labs/core 3.0.5 → 4.0.0

package/dist/pattern-index/indexer-lang.js

@@ -0,0 +1,244 @@
+/**
+ * Pattern Indexer — Language-Specific Extractors
+ *
+ * Standalone extraction functions for Go, Rust, JVM (Java/Kotlin/C#),
+ * Python, and a generic C-style fallback. Each function is pure and
+ * receives all required context as parameters.
+ */
+import * as path from 'path';
+import { createPatternEntry, extractKeywords, getCOMLineComments, getJavaDoc, findBraceBlockEnd, getBraceBlockContent, } from './indexer-helpers.js';
+// ---------------------------------------------------------------------------
+// Go
+// ---------------------------------------------------------------------------
+export function extractGoPatterns(filePath, content, rootDir) {
+    const patterns = [];
+    const relativePath = path.relative(rootDir, filePath);
+    const lines = content.split('\n');
+    const funcRegex = /^func\s+(?:\([^)]*\)\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*([^\{]*)\s*\{/;
+    const typeRegex = /^type\s+([A-Za-z_][A-Za-z0-9_]*)\s+(struct|interface)/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const funcMatch = line.match(funcRegex);
+        if (funcMatch) {
+            const name = funcMatch[1];
+            patterns.push(createPatternEntry({
+                type: 'function',
+                name,
+                file: relativePath,
+                line: i + 1,
+                endLine: findBraceBlockEnd(lines, i),
+                signature: `func ${name}(${funcMatch[2]}) ${funcMatch[3].trim()}`,
+                description: getCOMLineComments(lines, i - 1),
+                keywords: extractKeywords(name),
+                content: getBraceBlockContent(lines, i),
+                exported: /^[A-Z]/.test(name),
+            }));
+        }
+        const typeMatch = line.match(typeRegex);
+        if (typeMatch) {
+            const name = typeMatch[1];
+            patterns.push(createPatternEntry({
+                type: typeMatch[2],
+                name,
+                file: relativePath,
+                line: i + 1,
+                endLine: findBraceBlockEnd(lines, i),
+                signature: `type ${name} ${typeMatch[2]}`,
+                description: getCOMLineComments(lines, i - 1),
+                keywords: extractKeywords(name),
+                content: getBraceBlockContent(lines, i),
+                exported: /^[A-Z]/.test(name),
+            }));
+        }
+    }
+    return patterns;
+}
+// ---------------------------------------------------------------------------
+// Rust
+// ---------------------------------------------------------------------------
+export function extractRustPatterns(filePath, content, rootDir) {
+    const patterns = [];
+    const relativePath = path.relative(rootDir, filePath);
+    const lines = content.split('\n');
+    const fnRegex = /^(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_][A-Za-z0-9_]*)\s*[<(][^)]*[>)]\s*(?:->\s*[^\{]+)?\s*\{/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fnMatch = line.match(fnRegex);
+        if (fnMatch) {
+            const name = fnMatch[1];
+            patterns.push(createPatternEntry({
+                type: 'function',
+                name,
+                file: relativePath,
+                line: i + 1,
+                endLine: findBraceBlockEnd(lines, i),
+                signature: line.split('{')[0].trim(),
+                description: getCOMLineComments(lines, i - 1),
+                keywords: extractKeywords(name),
+                content: getBraceBlockContent(lines, i),
+                exported: line.startsWith('pub'),
+            }));
+        }
+    }
+    return patterns;
+}
+// ---------------------------------------------------------------------------
+// JVM-style (Java, Kotlin, C#)
+// ---------------------------------------------------------------------------
+export function extractJVMStylePatterns(filePath, content, rootDir) {
+    const patterns = [];
+    const relativePath = path.relative(rootDir, filePath);
+    const lines = content.split('\n');
+    const classRegex = /^(?:public|private|protected|internal)?\s*(?:static\s+)?(?:final\s+)?(?:class|interface|enum)\s+([A-Za-z0-9_]+)/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const classMatch = line.match(classRegex);
+        if (classMatch) {
+            patterns.push(createPatternEntry({
+                type: 'class',
+                name: classMatch[1],
+                file: relativePath,
+                line: i + 1,
+                endLine: findBraceBlockEnd(lines, i),
+                signature: line,
+                description: getJavaDoc(lines, i - 1),
+                keywords: extractKeywords(classMatch[1]),
+                content: getBraceBlockContent(lines, i),
+                exported: line.includes('public'),
+            }));
+        }
+    }
+    return patterns;
+}
+// ---------------------------------------------------------------------------
+// Generic C-style fallback (C++, PHP, etc.)
+// ---------------------------------------------------------------------------
+export function extractGenericCPatterns(_filePath, _content) {
+    return [];
+}
+// ---------------------------------------------------------------------------
+// Python
+// ---------------------------------------------------------------------------
+export function extractPythonPatterns(filePath, content, rootDir, minNameLength) {
+    const patterns = [];
+    const relativePath = path.relative(rootDir, filePath);
+    const lines = content.split('\n');
+    const classRegex = /^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*(\([^)]*\))?\s*:/;
+    const funcRegex = /^(?:async\s+)?def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*(?:->\s*[^:]+)?\s*:/;
+    const constRegex = /^([A-Z][A-Z0-9_]*)\s*=\s*(.+)$/;
+    for (let i = 0; i < lines.length; i++) {
+        const originalLine = lines[i];
+        const lineNum = i + 1;
+        const classMatch = originalLine.match(classRegex);
+        if (classMatch) {
+            const name = classMatch[1];
+            if (name.length >= minNameLength) {
+                patterns.push(createPatternEntry({
+                    type: detectPythonClassType(name),
+                    name,
+                    file: relativePath,
+                    line: lineNum,
+                    endLine: findPythonBlockEnd(lines, i),
+                    signature: `class ${name}${classMatch[2] || ''}`,
+                    description: getPythonDocstring(lines, i + 1),
+                    keywords: extractKeywords(name),
+                    content: getPythonBlockContent(lines, i),
+                    exported: !name.startsWith('_'),
+                }));
+                continue;
+            }
+        }
+        const funcMatch = originalLine.match(funcRegex);
+        if (funcMatch) {
+            const name = funcMatch[1];
+            if (name.length >= minNameLength) {
+                patterns.push(createPatternEntry({
+                    type: detectPythonFunctionType(name),
+                    name,
+                    file: relativePath,
+                    line: lineNum,
+                    endLine: findPythonBlockEnd(lines, i),
+                    signature: `def ${name}(${funcMatch[2]})`,
+                    description: getPythonDocstring(lines, i + 1),
+                    keywords: extractKeywords(name),
+                    content: getPythonBlockContent(lines, i),
+                    exported: !name.startsWith('_'),
+                }));
+                continue;
+            }
+        }
+        const constMatch = originalLine.match(constRegex);
+        if (constMatch) {
+            const name = constMatch[1];
+            if (name.length >= minNameLength) {
+                patterns.push(createPatternEntry({
+                    type: 'constant',
+                    name,
+                    file: relativePath,
+                    line: lineNum,
+                    endLine: lineNum,
+                    signature: `${name} = ...`,
+                    description: '',
+                    keywords: extractKeywords(name),
+                    content: originalLine,
+                    exported: !name.startsWith('_'),
+                }));
+            }
+        }
+    }
+    return patterns;
+}
+// ---------------------------------------------------------------------------
+// Python helpers (private to this module)
+// ---------------------------------------------------------------------------
+function detectPythonClassType(name) {
+    if (name.endsWith('Error') || name.endsWith('Exception'))
+        return 'error';
+    if (name.endsWith('Model'))
+        return 'model';
+    if (name.endsWith('Schema'))
+        return 'schema';
+    return 'class';
+}
+function detectPythonFunctionType(name) {
+    if (name.includes('middleware'))
+        return 'middleware';
+    if (name.includes('handler'))
+        return 'handler';
+    return 'function';
+}
+function getPythonDocstring(lines, startIndex) {
+    if (startIndex >= lines.length)
+        return '';
+    const nextLine = lines[startIndex].trim();
+    if (nextLine.startsWith('"""') || nextLine.startsWith("'''")) {
+        const quote = nextLine.startsWith('"""') ? '"""' : "'''";
+        let doc = nextLine.replace(quote, '');
+        if (doc.endsWith(quote))
+            return doc.replace(quote, '').trim();
+        for (let i = startIndex + 1; i < lines.length; i++) {
+            if (lines[i].includes(quote)) {
+                doc += ' ' + lines[i].split(quote)[0].trim();
+                break;
+            }
+            doc += ' ' + lines[i].trim();
+        }
+        return doc.trim();
+    }
+    return '';
+}
+function findPythonBlockEnd(lines, startIndex) {
+    const startIndent = lines[startIndex].search(/\S/);
+    for (let i = startIndex + 1; i < lines.length; i++) {
+        if (lines[i].trim() === '')
+            continue;
+        const currentIndent = lines[i].search(/\S/);
+        if (currentIndent <= startIndent)
+            return i;
+    }
+    return lines.length;
+}
+function getPythonBlockContent(lines, startIndex) {
+    const endLine = findPythonBlockEnd(lines, startIndex);
+    return lines.slice(startIndex, endLine).join('\n');
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Pattern Indexer — TypeScript / JavaScript AST Helpers
+ *
+ * Standalone functions for converting TypeScript AST nodes into PatternEntry
+ * records and extracting type metadata. No class state is referenced here.
+ */
+import ts from 'typescript';
+import type { PatternEntry, PatternType } from './types.js';
+/**
+ * Attempt to convert an AST node into a PatternEntry.
+ * Returns `null` for unrecognised node kinds.
+ */
+export declare function nodeToPattern(node: ts.Node, sourceFile: ts.SourceFile, filePath: string, _content: string, minNameLength: number): PatternEntry | null;
+export declare function detectFunctionType(name: string, node: ts.Node): PatternType;
+export declare function detectClassType(name: string, node: ts.ClassDeclaration): PatternType;
+export declare function getFunctionSignature(node: ts.FunctionDeclaration, sourceFile: ts.SourceFile): string;
+export declare function getArrowFunctionSignature(node: ts.ArrowFunction | ts.FunctionExpression, sourceFile: ts.SourceFile): string;
+export declare function getClassSignature(node: ts.ClassDeclaration, sourceFile: ts.SourceFile): string;
+export declare function getInterfaceSignature(node: ts.InterfaceDeclaration, sourceFile: ts.SourceFile): string;
+export declare function getJSDocDescription(node: ts.Node, sourceFile: ts.SourceFile): string;
+export declare function isExported(node: ts.Node): boolean;
+export declare function containsJSX(node: ts.Node): boolean;

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

@@ -0,0 +1,258 @@
+/**
+ * Pattern Indexer — TypeScript / JavaScript AST Helpers
+ *
+ * Standalone functions for converting TypeScript AST nodes into PatternEntry
+ * records and extracting type metadata. No class state is referenced here.
+ */
+import ts from 'typescript';
+import { createPatternEntry, extractKeywords } from './indexer-helpers.js';
+// ---------------------------------------------------------------------------
+// Main node → PatternEntry dispatcher
+// ---------------------------------------------------------------------------
+/**
+ * Attempt to convert an AST node into a PatternEntry.
+ * Returns `null` for unrecognised node kinds.
+ */
+export function nodeToPattern(node, sourceFile, filePath, _content, minNameLength) {
+    const startPos = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const endPos = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    const line = startPos.line + 1;
+    const endLine = endPos.line + 1;
+    // Function declarations
+    if (ts.isFunctionDeclaration(node) && node.name) {
+        const name = node.name.text;
+        if (name.length < minNameLength)
+            return null;
+        return createPatternEntry({
+            type: detectFunctionType(name, node),
+            name,
+            file: filePath,
+            line,
+            endLine,
+            signature: getFunctionSignature(node, sourceFile),
+            description: getJSDocDescription(node, sourceFile),
+            keywords: extractKeywords(name),
+            content: node.getText(sourceFile),
+            exported: isExported(node),
+        });
+    }
+    // Variable declarations with arrow functions or function expressions
+    if (ts.isVariableStatement(node)) {
+        for (const decl of node.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name) && decl.initializer) {
+                const name = decl.name.text;
+                if (name.length < minNameLength)
+                    continue;
+                if (ts.isArrowFunction(decl.initializer) ||
+                    ts.isFunctionExpression(decl.initializer)) {
+                    return createPatternEntry({
+                        type: detectFunctionType(name, decl.initializer),
+                        name,
+                        file: filePath,
+                        line,
+                        endLine,
+                        signature: getArrowFunctionSignature(decl.initializer, sourceFile),
+                        description: getJSDocDescription(node, sourceFile),
+                        keywords: extractKeywords(name),
+                        content: node.getText(sourceFile),
+                        exported: isExported(node),
+                    });
+                }
+                // Constants — UPPER_CASE `const` declarations with a simple initialiser
+                const isConst = node.declarationList.flags & ts.NodeFlags.Const;
+                if (isConst &&
+                    name === name.toUpperCase() &&
+                    (ts.isStringLiteral(decl.initializer) ||
+                        ts.isNumericLiteral(decl.initializer) ||
+                        ts.isObjectLiteralExpression(decl.initializer))) {
+                    return createPatternEntry({
+                        type: 'constant',
+                        name,
+                        file: filePath,
+                        line,
+                        endLine,
+                        signature: '',
+                        description: getJSDocDescription(node, sourceFile),
+                        keywords: extractKeywords(name),
+                        content: node.getText(sourceFile),
+                        exported: isExported(node),
+                    });
+                }
+            }
+        }
+    }
+    // Class declarations
+    if (ts.isClassDeclaration(node) && node.name) {
+        const name = node.name.text;
+        if (name.length < minNameLength)
+            return null;
+        return createPatternEntry({
+            type: detectClassType(name, node),
+            name,
+            file: filePath,
+            line,
+            endLine,
+            signature: getClassSignature(node, sourceFile),
+            description: getJSDocDescription(node, sourceFile),
+            keywords: extractKeywords(name),
+            content: node.getText(sourceFile),
+            exported: isExported(node),
+        });
+    }
+    // Interface declarations
+    if (ts.isInterfaceDeclaration(node)) {
+        const name = node.name.text;
+        if (name.length < minNameLength)
+            return null;
+        return createPatternEntry({
+            type: 'interface',
+            name,
+            file: filePath,
+            line,
+            endLine,
+            signature: getInterfaceSignature(node, sourceFile),
+            description: getJSDocDescription(node, sourceFile),
+            keywords: extractKeywords(name),
+            content: node.getText(sourceFile),
+            exported: isExported(node),
+        });
+    }
+    // Type alias declarations
+    if (ts.isTypeAliasDeclaration(node)) {
+        const name = node.name.text;
+        if (name.length < minNameLength)
+            return null;
+        return createPatternEntry({
+            type: 'type',
+            name,
+            file: filePath,
+            line,
+            endLine,
+            signature: node.getText(sourceFile).split('=')[0].trim(),
+            description: getJSDocDescription(node, sourceFile),
+            keywords: extractKeywords(name),
+            content: node.getText(sourceFile),
+            exported: isExported(node),
+        });
+    }
+    // Enum declarations
+    if (ts.isEnumDeclaration(node)) {
+        const name = node.name.text;
+        if (name.length < minNameLength)
+            return null;
+        return createPatternEntry({
+            type: 'enum',
+            name,
+            file: filePath,
+            line,
+            endLine,
+            signature: `enum ${name}`,
+            description: getJSDocDescription(node, sourceFile),
+            keywords: extractKeywords(name),
+            content: node.getText(sourceFile),
+            exported: isExported(node),
+        });
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Type detection
+// ---------------------------------------------------------------------------
+export function detectFunctionType(name, node) {
+    // React hooks — useXxx
+    if (name.startsWith('use') && name.length > 3 && name[3] === name[3].toUpperCase()) {
+        return 'hook';
+    }
+    // React components — PascalCase returning JSX
+    if (name[0] === name[0].toUpperCase() && containsJSX(node)) {
+        return 'component';
+    }
+    if (name.includes('Middleware') || name.includes('middleware'))
+        return 'middleware';
+    if (name.includes('Handler') || name.includes('handler'))
+        return 'handler';
+    if (name.startsWith('create') || name.startsWith('make') || name.includes('Factory'))
+        return 'factory';
+    return 'function';
+}
+export function detectClassType(name, node) {
+    if (name.endsWith('Error') || name.endsWith('Exception'))
+        return 'error';
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            const text = clause.getText();
+            if (text.includes('Component') || text.includes('PureComponent'))
+                return 'component';
+        }
+    }
+    if (name.endsWith('Store') || name.endsWith('State'))
+        return 'store';
+    if (name.endsWith('Model') || name.endsWith('Entity'))
+        return 'model';
+    return 'class';
+}
+// ---------------------------------------------------------------------------
+// Signature helpers
+// ---------------------------------------------------------------------------
+export function getFunctionSignature(node, sourceFile) {
+    const params = node.parameters.map(p => p.getText(sourceFile)).join(', ');
+    const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+    return `(${params})${returnType}`;
+}
+export function getArrowFunctionSignature(node, sourceFile) {
+    const params = node.parameters.map(p => p.getText(sourceFile)).join(', ');
+    const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+    return `(${params})${returnType}`;
+}
+export function getClassSignature(node, sourceFile) {
+    let sig = `class ${node.name?.text || 'Anonymous'}`;
+    if (node.heritageClauses) {
+        sig += ' ' + node.heritageClauses.map(c => c.getText(sourceFile)).join(' ');
+    }
+    return sig;
+}
+export function getInterfaceSignature(node, sourceFile) {
+    let sig = `interface ${node.name.text}`;
+    if (node.typeParameters) {
+        sig += `<${node.typeParameters.map(p => p.getText(sourceFile)).join(', ')}>`;
+    }
+    return sig;
+}
+// ---------------------------------------------------------------------------
+// JSDoc / export helpers
+// ---------------------------------------------------------------------------
+export function getJSDocDescription(node, sourceFile) {
+    const jsDocComment = ts.getJSDocCommentsAndTags(node);
+    for (const tag of jsDocComment) {
+        if (ts.isJSDoc(tag) && tag.comment) {
+            if (typeof tag.comment === 'string')
+                return tag.comment;
+            return tag.comment.map(c => c.getText(sourceFile)).join(' ');
+        }
+    }
+    return '';
+}
+export function isExported(node) {
+    if (ts.canHaveModifiers(node)) {
+        const modifiers = ts.getModifiers(node);
+        if (modifiers) {
+            return modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// JSX detection
+// ---------------------------------------------------------------------------
+export function containsJSX(node) {
+    let hasJSX = false;
+    const visit = (n) => {
+        if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+            hasJSX = true;
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return hasJSX;
+}

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

@@ -3,125 +3,23 @@
  *
  * Scans the codebase and extracts patterns using AST parsing.
  * This is the core engine of the Pattern Index system.
+ *
+ * Language-specific extractors live in indexer-lang.ts.
+ * TypeScript/JS AST helpers live in indexer-ts.ts.
+ * Pure utility functions live in indexer-helpers.ts.
  */
 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;
-    /**
-     * Extract patterns from Go files.
-     */
-    private extractGoPatterns;
-    /**
-     * Extract patterns from Rust files.
-     */
-    private extractRustPatterns;
-    /**
-     * Generic extraction for C-style languages (Java, C++, PHP, etc.)
-     */
-    private extractJVMStylePatterns;
-    private extractGenericCPatterns;
-    private getCOMLineComments;
-    private getJavaDoc;
-    private findBraceBlockEnd;
-    private getBraceBlockContent;
-    /**
-     * Extract patterns from Python files using regex.
-     */
-    private extractPythonPatterns;
-    private detectPythonClassType;
-    private detectPythonFunctionType;
-    private getPythonDocstring;
-    private findPythonBlockEnd;
-    private getPythonBlockContent;
-    /**
-     * 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;