skrypt-ai 0.5.0 → 0.6.0

package/dist/scanner/java.js

@@ -0,0 +1,318 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Java source files
+ * Extracts: public classes, public methods, public static methods
+ */
+export class JavaScanner {
+    languages = ['java'];
+    canHandle(filePath) {
+        return /\.java$/.test(filePath) && !filePath.includes('/test/') && !filePath.includes('Test.java');
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const lines = source.split('\n');
+            const packageName = this.extractPackage(source);
+            const imports = this.extractImports(source);
+            const classRanges = this.findClassRanges(source);
+            this.extractClasses(source, lines, filePath, packageName, imports, elements);
+            this.extractMethods(source, lines, filePath, packageName, imports, elements, classRanges);
+            this.extractInterfaceMethods(source, lines, filePath, packageName, imports, elements, classRanges);
+            return { filePath, language: 'java', elements, errors: [] };
+        }
+        catch (err) {
+            return { filePath, language: 'java', elements: [], errors: [`Failed to parse: ${err}`] };
+        }
+    }
+    extractPackage(source) {
+        const match = source.match(/^package\s+([\w.]+)\s*;/m);
+        return match?.[1] ?? 'unknown';
+    }
+    extractImports(source) {
+        const imports = [];
+        const regex = /^import\s+([\w.*]+)\s*;/gm;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+        return imports;
+    }
+    /**
+     * Extracts the full generics string starting at startIndex by counting `<>` depth.
+     * Returns empty string if source[startIndex] is not '<'.
+     */
+    extractGenerics(source, startIndex) {
+        if (source[startIndex] !== '<')
+            return '';
+        let depth = 0;
+        let i = startIndex;
+        while (i < source.length) {
+            if (source[i] === '<')
+                depth++;
+            else if (source[i] === '>') {
+                depth--;
+                if (depth === 0)
+                    return source.slice(startIndex, i + 1);
+            }
+            i++;
+        }
+        return '';
+    }
+    extractClasses(source, lines, filePath, packageName, imports, elements) {
+        // Match class declaration without capturing generics in the regex
+        const classRegex = /^(\s*)public\s+(?:(abstract|final)\s+)?(class|interface|enum|record)\s+(\w+)/gm;
+        let match;
+        while ((match = classRegex.exec(source)) !== null) {
+            const modifier = match[2] ?? '';
+            const kind = match[3];
+            const name = match[4];
+            if (!name)
+                continue;
+            // Extract generics using depth-counting helper
+            const afterName = match.index + match[0].length;
+            const generics = this.extractGenerics(source, afterName);
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getJavadoc(lines, lineNumber - 1);
+            const signature = `public ${modifier ? modifier + ' ' : ''}${kind} ${name}${generics}`;
+            elements.push({
+                kind: 'class',
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    extractMethods(source, lines, filePath, packageName, imports, elements, classRanges) {
+        // Match public methods (static or instance)
+        // public [static] [final] [async] ReturnType methodName<Generics>(params) [throws ...]
+        const methodRegex = /^(\s*)public\s+(?:(static|abstract|final|synchronized|native)\s+)*(?:(<[^>]+>)\s+)?([\w<>[\]?,\s]+?)\s+(\w+)\s*\(([^)]*)\)/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const indent = match[1] ?? '';
+            const name = match[5];
+            const paramsStr = match[6] ?? '';
+            const returnType = (match[4] ?? '').trim();
+            if (!name)
+                continue;
+            // Skip constructors (return type equals class name — handled as class)
+            // Skip if at top level (no indent = not inside a class)
+            if (indent.length === 0)
+                continue;
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getJavadoc(lines, lineNumber - 1);
+            const parameters = this.parseParams(paramsStr);
+            const parentClass = this.findParentClass(match.index, classRanges);
+            const fullMatch = match[0].trim();
+            const signature = fullMatch;
+            elements.push({
+                kind: 'method',
+                name,
+                signature,
+                parameters,
+                returnType: returnType === name ? undefined : returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    /**
+     * Extracts interface methods that don't have explicit `public` modifier.
+     * In Java, interface methods are implicitly public.
+     */
+    extractInterfaceMethods(source, lines, filePath, packageName, imports, elements, classRanges) {
+        const interfaceRanges = classRanges.filter(r => r.kind === 'interface');
+        for (const range of interfaceRanges) {
+            const body = source.slice(range.bodyStart, range.bodyEnd);
+            // Match: ReturnType methodName(params);
+            // Also handle generic return types like List<T>
+            const methodRegex = /^[ \t]*([^\s(;{}]+(?:<[^>]+>)?)\s+(\w+)\s*\(([^)]*)\)\s*;/gm;
+            let match;
+            while ((match = methodRegex.exec(body)) !== null) {
+                const returnType = match[1];
+                const name = match[2];
+                const paramsStr = match[3];
+                if (!name || !returnType || paramsStr === undefined)
+                    continue;
+                // Skip lines that look like non-method declarations
+                if (returnType === '//' || returnType === '/*' || returnType === '*')
+                    continue;
+                // Skip if this method was already extracted as a public method
+                const absoluteIndex = range.bodyStart + match.index;
+                const lineNumber = this.getLineNumber(source, absoluteIndex);
+                const alreadyExtracted = elements.some(e => e.kind === 'method' && e.name === name && e.lineNumber === lineNumber);
+                if (alreadyExtracted)
+                    continue;
+                const docstring = this.getJavadoc(lines, lineNumber - 1);
+                const parameters = this.parseParams(paramsStr);
+                const signature = `${returnType} ${name}(${paramsStr})`;
+                elements.push({
+                    kind: 'method',
+                    name,
+                    signature,
+                    parameters,
+                    returnType: returnType || undefined,
+                    docstring,
+                    filePath,
+                    lineNumber,
+                    parentClass: range.name,
+                    isExported: true,
+                    isPublic: true,
+                    imports,
+                    packageName,
+                    sourceContext: this.getSourceContext(lines, lineNumber)
+                });
+            }
+        }
+    }
+    /**
+     * Finds all class/interface/enum/record declarations and their brace-delimited ranges.
+     */
+    findClassRanges(source) {
+        const ranges = [];
+        const typeRegex = /^[ \t]*public\s+(?:(?:abstract|final)\s+)*(class|interface|enum|record)\s+(\w+)/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const kind = match[1];
+            const name = match[2];
+            if (!kind || !name)
+                continue;
+            // Find the opening brace after this match
+            const afterMatch = source.indexOf('{', match.index + match[0].length);
+            if (afterMatch === -1)
+                continue;
+            // Find matching closing brace
+            const bodyEnd = this.findMatchingBrace(source, afterMatch);
+            if (bodyEnd === -1)
+                continue;
+            ranges.push({
+                name,
+                kind,
+                start: match.index,
+                bodyStart: afterMatch + 1,
+                bodyEnd
+            });
+        }
+        return ranges;
+    }
+    findMatchingBrace(source, openIndex) {
+        let depth = 0;
+        for (let i = openIndex; i < source.length; i++) {
+            if (source[i] === '{')
+                depth++;
+            else if (source[i] === '}') {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Finds the innermost class that contains the given source index,
+     * using brace-depth-aware class ranges.
+     */
+    findParentClass(index, classRanges) {
+        let best;
+        for (const range of classRanges) {
+            if (index > range.bodyStart && index < range.bodyEnd) {
+                // Pick the innermost (smallest) range that contains this index
+                if (!best || (range.bodyEnd - range.bodyStart) < (best.bodyEnd - best.bodyStart)) {
+                    best = range;
+                }
+            }
+        }
+        return best?.name;
+    }
+    parseParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Handle annotations like @NotNull
+            const cleaned = trimmed.replace(/@\w+\s*/g, '').trim();
+            // Handle final modifier
+            const withoutFinal = cleaned.replace(/^final\s+/, '');
+            const lastSpace = withoutFinal.lastIndexOf(' ');
+            if (lastSpace > 0) {
+                const type = withoutFinal.slice(0, lastSpace).trim();
+                const name = withoutFinal.slice(lastSpace + 1).trim();
+                // Handle varargs
+                const actualType = type.replace(/\.\.\./, '[]');
+                params.push({ name: name.replace(/\.\.\./, ''), type: actualType });
+            }
+        }
+        return params;
+    }
+    splitParams(str) {
+        const parts = [];
+        let depth = 0;
+        let current = '';
+        for (const char of str) {
+            if (char === '<' || char === '(' || char === '[')
+                depth++;
+            else if (char === '>' || char === ')' || char === ']')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                parts.push(current);
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim())
+            parts.push(current);
+        return parts;
+    }
+    getLineNumber(source, index) {
+        return source.slice(0, index).split('\n').length;
+    }
+    getJavadoc(lines, lineIndex) {
+        let i = lineIndex - 1;
+        // Skip annotations
+        while (i >= 0 && lines[i]?.trim().startsWith('@'))
+            i--;
+        // Skip blank lines
+        while (i >= 0 && lines[i]?.trim() === '')
+            i--;
+        if (i >= 0 && lines[i]?.trim().endsWith('*/')) {
+            let start = i;
+            while (start >= 0 && !lines[start]?.includes('/**'))
+                start--;
+            if (start >= 0) {
+                return lines.slice(start, i + 1).join('\n')
+                    .replace(/\/\*\*/, '').replace(/\*\//, '')
+                    .split('\n')
+                    .map(l => l.trim().replace(/^\*\s?/, ''))
+                    .filter(Boolean)
+                    .join('\n');
+            }
+        }
+        return undefined;
+    }
+    getSourceContext(lines, lineNumber, context = 5) {
+        const start = Math.max(0, lineNumber - context - 1);
+        const end = Math.min(lines.length, lineNumber + context);
+        return lines.slice(start, end).join('\n');
+    }
+}

package/dist/scanner/kotlin.d.ts

@@ -0,0 +1,23 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Kotlin source files
+ * Extracts: classes, data classes, sealed classes, objects, interfaces, enum classes, functions
+ */
+export declare class KotlinScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractImports;
+    private extractParenContent;
+    private extractGenerics;
+    private extractTypes;
+    private extractFunctions;
+    private buildClassMap;
+    private findClosingBrace;
+    private findParentClass;
+    private parseKotlinParams;
+    private splitParams;
+    private getLineNumber;
+    private getDocComment;
+    private getSourceContext;
+}