@rigour-labs/core 3.0.4 → 3.0.6

package/dist/gates/test-quality-lang.js

@@ -0,0 +1,188 @@
+/**
+ * Language-specific test quality checks for Go and Java/Kotlin.
+ * Extracted from test-quality.ts to keep it under 500 lines.
+ */
+/**
+ * Go test quality checks.
+ * Go tests use func TestXxx(t *testing.T) pattern.
+ * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
+ * Also checks for t.Run subtests and table-driven patterns.
+ */
+export function checkGoTestQuality(content, file, issues, config) {
+    const lines = content.split('\n');
+    let inTestFunc = false;
+    let testStartLine = 0;
+    let braceDepth = 0;
+    let hasAssertion = false;
+    let testContent = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Detect test function: func TestXxx(t *testing.T) {
+        const testMatch = trimmed.match(/^func\s+(Test\w+|Benchmark\w+)\s*\(/);
+        if (testMatch && !inTestFunc) {
+            inTestFunc = true;
+            testStartLine = i + 1;
+            braceDepth = 0;
+            hasAssertion = false;
+            testContent = '';
+            // Count braces on this line
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            continue;
+        }
+        if (inTestFunc) {
+            testContent += line + '\n';
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            // Go test assertions: t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow
+            // Also: assert/require from testify, t.Run for subtests
+            if (/\bt\.\s*(?:Fatal|Error|Fatalf|Errorf|Fail|FailNow|Log|Logf|Skip|Skipf|Helper)\s*\(/.test(line) ||
+                /\bt\.Run\s*\(/.test(line) ||
+                /\bassert\.\w+\s*\(/.test(line) || /\brequire\.\w+\s*\(/.test(line) ||
+                /\bif\b.*\bt\./.test(line)) {
+                hasAssertion = true;
+            }
+            // Tautological: if true { t.Fatal... } or assert.True(t, true)
+            if (config.check_tautological) {
+                if (/assert\.True\s*\(\s*\w+\s*,\s*true\s*\)/.test(line) ||
+                    /assert\.Equal\s*\(\s*\w+\s*,\s*(\d+|"[^"]*")\s*,\s*\1\s*\)/.test(line)) {
+                    issues.push({
+                        file, line: i + 1, pattern: 'tautological-assertion',
+                        reason: 'Tautological assertion — comparing a constant to itself proves nothing',
+                    });
+                }
+            }
+            // End of function
+            if (braceDepth === 0 && testContent.trim()) {
+                const meaningful = testContent.split('\n').filter(l => {
+                    const t = l.trim();
+                    return t && t !== '{' && t !== '}' && !t.startsWith('//');
+                });
+                if (config.check_empty_tests && meaningful.length === 0) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'empty-test',
+                        reason: 'Empty test function — no test logic',
+                    });
+                }
+                else if (config.check_empty_tests && !hasAssertion && meaningful.length > 0) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'no-assertion',
+                        reason: 'Test has no assertions (t.Error, t.Fatal, assert.*) — executes code but never verifies',
+                    });
+                }
+                inTestFunc = false;
+            }
+        }
+    }
+}
+/**
+ * Java/Kotlin test quality checks.
+ * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
+ * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
+ * Kotlin: @Test + kotlin.test assertEquals, etc.
+ */
+export function checkJavaKotlinTestQuality(content, file, ext, issues, config) {
+    const lines = content.split('\n');
+    const isKotlin = ext === '.kt';
+    let inTestMethod = false;
+    let testStartLine = 0;
+    let braceDepth = 0;
+    let hasAssertion = false;
+    let mockCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Detect @Test annotation (next non-empty line is the method)
+        if (trimmed === '@Test' || /^@Test\s*(\(|$)/.test(trimmed)) {
+            // Look for the method signature on this or next lines
+            for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
+                const methodLine = lines[j].trim();
+                const methodMatch = isKotlin
+                    ? methodLine.match(/^(?:fun|suspend\s+fun)\s+(\w+)\s*\(/)
+                    : methodLine.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?void\s+(\w+)\s*\(/);
+                if (methodMatch) {
+                    inTestMethod = true;
+                    testStartLine = j + 1;
+                    braceDepth = 0;
+                    hasAssertion = false;
+                    mockCount = 0;
+                    // Count braces
+                    for (const ch of lines[j]) {
+                        if (ch === '{')
+                            braceDepth++;
+                        if (ch === '}')
+                            braceDepth--;
+                    }
+                    i = j;
+                    break;
+                }
+            }
+            continue;
+        }
+        if (inTestMethod) {
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            // JUnit 4/5 assertions
+            if (/\b(?:assert(?:Equals|True|False|NotNull|Null|That|Throws|DoesNotThrow|Same|NotSame|ArrayEquals)|assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertThrows)\s*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Kotlin test assertions
+            if (isKotlin && /\b(?:assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertFailsWith|assertIs|assertContains|expect)\s*[({]/.test(line)) {
+                hasAssertion = true;
+            }
+            // Hamcrest / AssertJ
+            if (/\bassertThat\s*\(/.test(line) || /\.should\w*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Verify (Mockito)
+            if (/\bverify\s*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Mock counting
+            if (/\b(?:mock|spy|when|doReturn|doThrow|doNothing|Mockito\.\w+)\s*\(/.test(line) ||
+                /@Mock\b/.test(line) || /@InjectMocks\b/.test(line)) {
+                mockCount++;
+            }
+            // Tautological
+            if (config.check_tautological) {
+                if (/assertEquals\s*\(\s*true\s*,\s*true\s*\)/.test(line) ||
+                    /assertTrue\s*\(\s*true\s*\)/.test(line) ||
+                    /assertEquals\s*\(\s*(\d+)\s*,\s*\1\s*\)/.test(line)) {
+                    issues.push({
+                        file, line: i + 1, pattern: 'tautological-assertion',
+                        reason: 'Tautological assertion — comparing a constant to itself proves nothing',
+                    });
+                }
+            }
+            // End of method
+            if (braceDepth === 0) {
+                if (config.check_empty_tests && !hasAssertion) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'no-assertion',
+                        reason: 'Test has no assertions — executes code but never verifies results',
+                    });
+                }
+                if (config.check_mock_heavy && mockCount > config.max_mocks_per_test) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'mock-heavy',
+                        reason: `Test uses ${mockCount} mocks (max: ${config.max_mocks_per_test}) — may be testing mocks, not real behavior`,
+                    });
+                }
+                inTestMethod = false;
+            }
+        }
+    }
+}

package/dist/gates/test-quality.d.ts

@@ -50,18 +50,4 @@ export declare class TestQualityGate extends Gate {
     private analyzeJSTestBlock;
     private checkPythonTestQuality;
     private analyzePythonTestBlock;
-    /**
-     * Go test quality checks.
-     * Go tests use func TestXxx(t *testing.T) pattern.
-     * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
-     * Also checks for t.Run subtests and table-driven patterns.
-     */
-    private checkGoTestQuality;
-    /**
-     * Java/Kotlin test quality checks.
-     * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
-     * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
-     * Kotlin: @Test + kotlin.test assertEquals, etc.
-     */
-    private checkJavaKotlinTestQuality;
 }

package/dist/gates/test-quality.js

@@ -26,6 +26,7 @@
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
+import { checkGoTestQuality, checkJavaKotlinTestQuality } from './test-quality-lang.js';
 import fs from 'fs-extra';
 import path from 'path';
 export class TestQualityGate extends Gate {
@@ -76,10 +77,20 @@ export class TestQualityGate extends Gate {
                     this.checkPythonTestQuality(content, file, issues);
                 }
                 else if (ext === '.go') {
-                    this.checkGoTestQuality(content, file, issues);
+                    checkGoTestQuality(content, file, issues, {
+                        check_empty_tests: this.config.check_empty_tests,
+                        check_tautological: this.config.check_tautological,
+                        check_mock_heavy: this.config.check_mock_heavy,
+                        max_mocks_per_test: this.config.max_mocks_per_test,
+                    });
                 }
                 else if (ext === '.java' || ext === '.kt') {
-                    this.checkJavaKotlinTestQuality(content, file, ext, issues);
+                    checkJavaKotlinTestQuality(content, file, ext, issues, {
+                        check_empty_tests: this.config.check_empty_tests,
+                        check_tautological: this.config.check_tautological,
+                        check_mock_heavy: this.config.check_mock_heavy,
+                        max_mocks_per_test: this.config.max_mocks_per_test,
+                    });
                 }
             }
             catch { /* skip */ }
@@ -325,188 +336,4 @@ export class TestQualityGate extends Gate {
             });
         }
     }
-    /**
-     * Go test quality checks.
-     * Go tests use func TestXxx(t *testing.T) pattern.
-     * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
-     * Also checks for t.Run subtests and table-driven patterns.
-     */
-    checkGoTestQuality(content, file, issues) {
-        const lines = content.split('\n');
-        let inTestFunc = false;
-        let testStartLine = 0;
-        let braceDepth = 0;
-        let hasAssertion = false;
-        let testContent = '';
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Detect test function: func TestXxx(t *testing.T) {
-            const testMatch = trimmed.match(/^func\s+(Test\w+|Benchmark\w+)\s*\(/);
-            if (testMatch && !inTestFunc) {
-                inTestFunc = true;
-                testStartLine = i + 1;
-                braceDepth = 0;
-                hasAssertion = false;
-                testContent = '';
-                // Count braces on this line
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                continue;
-            }
-            if (inTestFunc) {
-                testContent += line + '\n';
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                // Go test assertions: t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow
-                // Also: assert/require from testify, t.Run for subtests
-                if (/\bt\.\s*(?:Fatal|Error|Fatalf|Errorf|Fail|FailNow|Log|Logf|Skip|Skipf|Helper)\s*\(/.test(line) ||
-                    /\bt\.Run\s*\(/.test(line) ||
-                    /\bassert\.\w+\s*\(/.test(line) || /\brequire\.\w+\s*\(/.test(line) ||
-                    /\bif\b.*\bt\./.test(line)) {
-                    hasAssertion = true;
-                }
-                // Tautological: if true { t.Fatal... } or assert.True(t, true)
-                if (this.config.check_tautological) {
-                    if (/assert\.True\s*\(\s*\w+\s*,\s*true\s*\)/.test(line) ||
-                        /assert\.Equal\s*\(\s*\w+\s*,\s*(\d+|"[^"]*")\s*,\s*\1\s*\)/.test(line)) {
-                        issues.push({
-                            file, line: i + 1, pattern: 'tautological-assertion',
-                            reason: 'Tautological assertion — comparing a constant to itself proves nothing',
-                        });
-                    }
-                }
-                // End of function
-                if (braceDepth === 0 && testContent.trim()) {
-                    const meaningful = testContent.split('\n').filter(l => {
-                        const t = l.trim();
-                        return t && t !== '{' && t !== '}' && !t.startsWith('//');
-                    });
-                    if (this.config.check_empty_tests && meaningful.length === 0) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'empty-test',
-                            reason: 'Empty test function — no test logic',
-                        });
-                    }
-                    else if (this.config.check_empty_tests && !hasAssertion && meaningful.length > 0) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'no-assertion',
-                            reason: 'Test has no assertions (t.Error, t.Fatal, assert.*) — executes code but never verifies',
-                        });
-                    }
-                    inTestFunc = false;
-                }
-            }
-        }
-    }
-    /**
-     * Java/Kotlin test quality checks.
-     * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
-     * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
-     * Kotlin: @Test + kotlin.test assertEquals, etc.
-     */
-    checkJavaKotlinTestQuality(content, file, ext, issues) {
-        const lines = content.split('\n');
-        const isKotlin = ext === '.kt';
-        let inTestMethod = false;
-        let testStartLine = 0;
-        let braceDepth = 0;
-        let hasAssertion = false;
-        let mockCount = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Detect @Test annotation (next non-empty line is the method)
-            if (trimmed === '@Test' || /^@Test\s*(\(|$)/.test(trimmed)) {
-                // Look for the method signature on this or next lines
-                for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
-                    const methodLine = lines[j].trim();
-                    const methodMatch = isKotlin
-                        ? methodLine.match(/^(?:fun|suspend\s+fun)\s+(\w+)\s*\(/)
-                        : methodLine.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?void\s+(\w+)\s*\(/);
-                    if (methodMatch) {
-                        inTestMethod = true;
-                        testStartLine = j + 1;
-                        braceDepth = 0;
-                        hasAssertion = false;
-                        mockCount = 0;
-                        // Count braces
-                        for (const ch of lines[j]) {
-                            if (ch === '{')
-                                braceDepth++;
-                            if (ch === '}')
-                                braceDepth--;
-                        }
-                        i = j;
-                        break;
-                    }
-                }
-                continue;
-            }
-            if (inTestMethod) {
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                // JUnit 4/5 assertions
-                if (/\b(?:assert(?:Equals|True|False|NotNull|Null|That|Throws|DoesNotThrow|Same|NotSame|ArrayEquals)|assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertThrows)\s*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Kotlin test assertions
-                if (isKotlin && /\b(?:assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertFailsWith|assertIs|assertContains|expect)\s*[({]/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Hamcrest / AssertJ
-                if (/\bassertThat\s*\(/.test(line) || /\.should\w*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Verify (Mockito)
-                if (/\bverify\s*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Mock counting
-                if (/\b(?:mock|spy|when|doReturn|doThrow|doNothing|Mockito\.\w+)\s*\(/.test(line) ||
-                    /@Mock\b/.test(line) || /@InjectMocks\b/.test(line)) {
-                    mockCount++;
-                }
-                // Tautological
-                if (this.config.check_tautological) {
-                    if (/assertEquals\s*\(\s*true\s*,\s*true\s*\)/.test(line) ||
-                        /assertTrue\s*\(\s*true\s*\)/.test(line) ||
-                        /assertEquals\s*\(\s*(\d+)\s*,\s*\1\s*\)/.test(line)) {
-                        issues.push({
-                            file, line: i + 1, pattern: 'tautological-assertion',
-                            reason: 'Tautological assertion — comparing a constant to itself proves nothing',
-                        });
-                    }
-                }
-                // End of method
-                if (braceDepth === 0) {
-                    if (this.config.check_empty_tests && !hasAssertion) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'no-assertion',
-                            reason: 'Test has no assertions — executes code but never verifies results',
-                        });
-                    }
-                    if (this.config.check_mock_heavy && mockCount > this.config.max_mocks_per_test) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'mock-heavy',
-                            reason: `Test uses ${mockCount} mocks (max: ${this.config.max_mocks_per_test}) — may be testing mocks, not real behavior`,
-                        });
-                    }
-                    inTestMethod = false;
-                }
-            }
-        }
-    }
 }

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

@@ -0,0 +1,38 @@
+/**
+ * Pattern Indexer — Pure Utility Helpers
+ *
+ * Standalone pure functions shared across language extractors and the main
+ * indexer class. No class state is referenced here.
+ */
+import type { PatternEntry, PatternType } from './types.js';
+/** SHA-256 of `content`, truncated to 16 hex chars. */
+export declare function hashContent(content: string): string;
+export interface PatternEntryParams {
+    type: PatternType;
+    name: string;
+    file: string;
+    line: number;
+    endLine: number;
+    signature: string;
+    description: string;
+    keywords: string[];
+    content: string;
+    exported: boolean;
+}
+/** Build a complete PatternEntry from constituent parts. */
+export declare function createPatternEntry(params: PatternEntryParams): PatternEntry;
+/** Split camelCase / PascalCase / snake_case names into unique lowercase words. */
+export declare function extractKeywords(name: string): string[];
+/** Walk forward from `startIndex` and return the line index after the closing brace. */
+export declare function findBraceBlockEnd(lines: string[], startIndex: number): number;
+/** Return the source lines for a brace-delimited block starting at `startIndex`. */
+export declare function getBraceBlockContent(lines: string[], startIndex: number): string;
+/**
+ * Collect consecutive `//` comments immediately above `startIndex` (Go / Rust style).
+ * Walks upward until a non-comment line is encountered.
+ */
+export declare function getCOMLineComments(lines: string[], startIndex: number): string;
+/**
+ * Extract the first JavaDoc `/** … *\/` comment block found above `startIndex`.
+ */
+export declare function getJavaDoc(lines: string[], startIndex: number): string;

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

@@ -0,0 +1,111 @@
+/**
+ * Pattern Indexer — Pure Utility Helpers
+ *
+ * Standalone pure functions shared across language extractors and the main
+ * indexer class. No class state is referenced here.
+ */
+import { createHash } from 'crypto';
+// ---------------------------------------------------------------------------
+// Hashing / ID generation
+// ---------------------------------------------------------------------------
+/** SHA-256 of `content`, truncated to 16 hex chars. */
+export function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+/** Build a complete PatternEntry from constituent parts. */
+export function createPatternEntry(params) {
+    const id = hashContent(`${params.file}:${params.name}:${params.line}`);
+    const hash = hashContent(params.content);
+    return {
+        id,
+        type: params.type,
+        name: params.name,
+        file: params.file,
+        line: params.line,
+        endLine: params.endLine,
+        signature: params.signature,
+        description: params.description,
+        keywords: params.keywords,
+        hash,
+        exported: params.exported,
+        usageCount: 0,
+        indexedAt: new Date().toISOString(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Keyword extraction
+// ---------------------------------------------------------------------------
+/** Split camelCase / PascalCase / snake_case names into unique lowercase words. */
+export function extractKeywords(name) {
+    const words = name
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .filter(w => w.length > 1);
+    return [...new Set(words)];
+}
+// ---------------------------------------------------------------------------
+// Brace-based block helpers (Go, Rust, JVM, C-style)
+// ---------------------------------------------------------------------------
+/** Walk forward from `startIndex` and return the line index after the closing brace. */
+export function findBraceBlockEnd(lines, startIndex) {
+    let braceCount = 0;
+    let started = false;
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes('{')) {
+            braceCount += (line.match(/\{/g) || []).length;
+            started = true;
+        }
+        if (line.includes('}')) {
+            braceCount -= (line.match(/\}/g) || []).length;
+        }
+        if (started && braceCount === 0)
+            return i + 1;
+    }
+    return lines.length;
+}
+/** Return the source lines for a brace-delimited block starting at `startIndex`. */
+export function getBraceBlockContent(lines, startIndex) {
+    const end = findBraceBlockEnd(lines, startIndex);
+    return lines.slice(startIndex, end).join('\n');
+}
+// ---------------------------------------------------------------------------
+// Comment extraction helpers
+// ---------------------------------------------------------------------------
+/**
+ * Collect consecutive `//` comments immediately above `startIndex` (Go / Rust style).
+ * Walks upward until a non-comment line is encountered.
+ */
+export function getCOMLineComments(lines, startIndex) {
+    const comments = [];
+    for (let i = startIndex; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.startsWith('//')) {
+            comments.unshift(line.replace('//', '').trim());
+        }
+        else {
+            break;
+        }
+    }
+    return comments.join(' ');
+}
+/**
+ * Extract the first JavaDoc `/** … *\/` comment block found above `startIndex`.
+ */
+export function getJavaDoc(lines, startIndex) {
+    const comments = [];
+    let inDoc = false;
+    for (let i = startIndex; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.endsWith('*/'))
+            inDoc = true;
+        if (inDoc) {
+            comments.unshift(line.replace('/**', '').replace('*/', '').replace(/^\*/, '').trim());
+        }
+        if (line.startsWith('/**'))
+            break;
+    }
+    return comments.join(' ');
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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 type { PatternEntry } from './types.js';
+export declare function extractGoPatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractRustPatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractJVMStylePatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractGenericCPatterns(_filePath: string, _content: string): PatternEntry[];
+export declare function extractPythonPatterns(filePath: string, content: string, rootDir: string, minNameLength: number): PatternEntry[];