skrypt-ai 0.5.0 → 0.6.0

package/dist/scanner/kotlin.js

@@ -0,0 +1,389 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Kotlin source files
+ * Extracts: classes, data classes, sealed classes, objects, interfaces, enum classes, functions
+ */
+export class KotlinScanner {
+    languages = ['kotlin'];
+    canHandle(filePath) {
+        return /\.kts?$/.test(filePath) &&
+            !filePath.includes('Test.kt') &&
+            !filePath.includes('/test/');
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Extract package name
+            const packageMatch = source.match(/^package\s+([\w.]+)/m);
+            const packageName = packageMatch?.[1] ?? 'unknown';
+            // Extract imports for context
+            const imports = this.extractImports(source);
+            // Find all classes, interfaces, objects, enums
+            this.extractTypes(source, lines, filePath, packageName, imports, elements);
+            // Find top-level and class-level functions
+            this.extractFunctions(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'kotlin',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'kotlin',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    extractImports(source) {
+        const imports = [];
+        const regex = /^import\s+([\w.*]+)/gm;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+        return imports;
+    }
+    extractParenContent(source, openIndex) {
+        if (source[openIndex] !== '(')
+            return null;
+        let depth = 0;
+        for (let i = openIndex; i < source.length; i++) {
+            if (source[i] === '(')
+                depth++;
+            else if (source[i] === ')') {
+                depth--;
+                if (depth === 0)
+                    return source.slice(openIndex + 1, i);
+            }
+        }
+        return null;
+    }
+    extractGenerics(source, startIndex) {
+        if (startIndex >= source.length || 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 '';
+    }
+    extractTypes(source, lines, filePath, packageName, imports, elements) {
+        // Match: class, data class, sealed class, abstract class, object, interface, enum class
+        // Captures optional leading whitespace, visibility modifier, type keyword(s), and name
+        // Generics and constructor params are extracted post-match via helpers
+        const typeRegex = /^[ \t]*(?:(?:public|open)\s+)?(?:(data|sealed|enum|abstract|annotation|value|inner)\s+)?(class|interface|object)\s+(\w+)/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const modifier = match[1] ?? ''; // data, sealed, enum, abstract
+            const keyword = match[2]; // class, interface, object
+            const name = match[3];
+            if (!keyword || !name)
+                continue;
+            const lineNumber = this.getLineNumber(source, match.index);
+            // Skip private and internal types
+            const fullLine = lines[lineNumber - 1];
+            if (fullLine && /\b(private|internal)\b/.test(fullLine))
+                continue;
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            // Extract generics post-match (handles nested generics like <T : Comparable<T>>)
+            let afterName = match.index + match[0].length;
+            // Skip whitespace
+            while (afterName < source.length && /\s/.test(source[afterName]))
+                afterName++;
+            const generics = this.extractGenerics(source, afterName);
+            if (generics)
+                afterName += generics.length;
+            // Skip whitespace after generics
+            while (afterName < source.length && /\s/.test(source[afterName]))
+                afterName++;
+            // Extract constructor params via depth-counting helper
+            let paramsStr;
+            if (source[afterName] === '(') {
+                const content = this.extractParenContent(source, afterName);
+                if (content !== null)
+                    paramsStr = content;
+            }
+            // Build signature
+            const prefix = modifier ? `${modifier} ${keyword}` : keyword;
+            const signature = `${prefix} ${name}${generics}${paramsStr !== undefined ? `(${paramsStr})` : ''}`;
+            // Parse constructor params for data classes
+            const parameters = paramsStr !== undefined ? this.parseKotlinParams(paramsStr) : [];
+            elements.push({
+                kind: 'class',
+                name,
+                signature,
+                parameters,
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    extractFunctions(source, lines, filePath, packageName, imports, elements) {
+        // Find class bodies so we can determine parentClass for methods
+        const classMap = this.buildClassMap(source);
+        // Match up to the opening paren; params and generics extracted via helpers
+        // Skip private and internal functions
+        const funcRegex = /^(\s*)(?:(?:public|protected|open|override)\s+)*(suspend\s+)?fun\s+(?:[\w<>,\s?*]+\.)?([\w]+)\s*(?:<|\()/gm;
+        let match;
+        while ((match = funcRegex.exec(source)) !== null) {
+            const indent = match[1] ?? '';
+            const suspendKeyword = match[2];
+            const name = match[3];
+            if (!name)
+                continue;
+            // Check if this function is preceded by 'private' or 'internal' on the same line
+            const lineNumber = this.getLineNumber(source, match.index);
+            const fullLine = lines[lineNumber - 1];
+            if (fullLine && /\b(private|internal)\b/.test(fullLine))
+                continue;
+            // After the function name, extract optional generics and then params
+            const nameEnd = match.index + match[0].length - 1; // position of '<' or '('
+            let cursor = nameEnd;
+            // Skip whitespace before potential generics
+            while (cursor < source.length && /\s/.test(source[cursor]))
+                cursor++;
+            // Extract generics if present (handles nested like <T : Comparable<T>>)
+            let generics = '';
+            if (source[cursor] === '<') {
+                generics = this.extractGenerics(source, cursor);
+                if (generics)
+                    cursor += generics.length;
+                // Skip whitespace after generics
+                while (cursor < source.length && /\s/.test(source[cursor]))
+                    cursor++;
+            }
+            // Extract params via depth-counting
+            if (source[cursor] !== '(')
+                continue;
+            const paramsStr = this.extractParenContent(source, cursor);
+            if (paramsStr === null)
+                continue;
+            // Move cursor past closing paren
+            cursor += paramsStr.length + 2; // +2 for '(' and ')'
+            // Extract return type: look for ': ReturnType' before '{', '=', or newline
+            let returnType;
+            let afterParen = cursor;
+            while (afterParen < source.length && /\s/.test(source[afterParen]))
+                afterParen++;
+            if (source[afterParen] === ':') {
+                afterParen++; // skip ':'
+                while (afterParen < source.length && source[afterParen] === ' ')
+                    afterParen++;
+                let retEnd = afterParen;
+                while (retEnd < source.length && source[retEnd] !== '\n' && source[retEnd] !== '{' && source[retEnd] !== '=') {
+                    retEnd++;
+                }
+                const retStr = source.slice(afterParen, retEnd).trim();
+                if (retStr)
+                    returnType = retStr;
+            }
+            // Verify the line ends with '{', '=', or end-of-line (to avoid matching partial text)
+            // This is already handled by the extraction logic above
+            const isAsync = !!suspendKeyword;
+            const parentClass = this.findParentClass(source, match.index, classMap, indent);
+            const isSuspend = isAsync ? 'suspend ' : '';
+            const signature = `${isSuspend}fun ${name}${generics}(${paramsStr})${returnType ? ': ' + returnType : ''}`;
+            const parameters = this.parseKotlinParams(paramsStr);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            elements.push({
+                kind: parentClass ? 'method' : 'function',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass,
+                isAsync,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    buildClassMap(source) {
+        const classes = [];
+        // Match class/object/interface declarations with opening brace (including indented nested classes)
+        const classRegex = /^[ \t]*(?:(?:public|open|abstract|sealed|data|enum)\s+)*(?:class|interface|object)\s+(\w+)[^{]*\{/gm;
+        let match;
+        while ((match = classRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            const start = match.index;
+            const braceStart = source.indexOf('{', start + match[0].length - 1);
+            const end = this.findClosingBrace(source, braceStart);
+            if (end > start) {
+                classes.push({ name, start, end });
+            }
+        }
+        return classes;
+    }
+    findClosingBrace(source, openBraceIndex) {
+        let depth = 0;
+        for (let i = openBraceIndex; i < source.length; i++) {
+            if (source[i] === '{')
+                depth++;
+            else if (source[i] === '}') {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return source.length;
+    }
+    findParentClass(source, index, classMap, indent) {
+        // A function is a method if it's inside a class body (indented or within class braces)
+        for (const cls of classMap) {
+            if (index > cls.start && index < cls.end && indent.length > 0) {
+                return cls.name;
+            }
+        }
+        return undefined;
+    }
+    parseKotlinParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            let trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Remove val/var prefix (constructor params)
+            trimmed = trimmed.replace(/^(val|var)\s+/, '');
+            // Format: "name: Type" or "name: Type = default"
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx > 0) {
+                const name = trimmed.slice(0, colonIdx).trim();
+                let typeAndDefault = trimmed.slice(colonIdx + 1).trim();
+                let defaultValue;
+                // Check for default value — split on '=' but not '==' or '=>'
+                const eqIdx = typeAndDefault.search(/(?<!=)=(?!=|>)/);
+                if (eqIdx > 0) {
+                    defaultValue = typeAndDefault.slice(eqIdx + 1).trim();
+                    typeAndDefault = typeAndDefault.slice(0, eqIdx).trim();
+                }
+                const type = typeAndDefault || undefined;
+                const param = { name, type };
+                if (defaultValue !== undefined) {
+                    param.default = defaultValue;
+                }
+                params.push(param);
+            }
+            else {
+                // Just a name with no type annotation
+                params.push({ name: trimmed, type: undefined });
+            }
+        }
+        return params;
+    }
+    splitParams(str) {
+        const parts = [];
+        let depth = 0;
+        let current = '';
+        for (const char of str) {
+            if (char === '<' || char === '(' || char === '[' || char === '{')
+                depth++;
+            else if (char === '>' || 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;
+    }
+    getDocComment(lines, lineIndex) {
+        // Look for KDoc comments (/** ... */) above the declaration
+        let i = lineIndex - 1;
+        // Skip blank lines
+        while (i >= 0 && lines[i]?.trim() === '') {
+            i--;
+        }
+        if (i < 0)
+            return undefined;
+        const currentLine = lines[i];
+        if (!currentLine)
+            return undefined;
+        // Check if the line ends with */ (end of KDoc block)
+        if (currentLine.trim().endsWith('*/')) {
+            // Find the start of the block comment
+            let start = i;
+            while (start >= 0 && !lines[start]?.includes('/**')) {
+                start--;
+            }
+            if (start >= 0 && lines[start]) {
+                const block = lines.slice(start, i + 1).join('\n');
+                const cleaned = block
+                    .replace(/\/\*\*/, '')
+                    .replace(/\*\//, '')
+                    .split('\n')
+                    .map(l => l.trim().replace(/^\*\s?/, ''))
+                    .filter(Boolean)
+                    .join('\n');
+                return cleaned || undefined;
+            }
+        }
+        // Check for single-line KDoc: /** ... */
+        const singleLineMatch = currentLine.trim().match(/^\/\*\*\s*(.*?)\s*\*\/$/);
+        if (singleLineMatch?.[1]) {
+            return singleLineMatch[1];
+        }
+        // Check for // style comments
+        const comments = [];
+        while (i >= 0) {
+            const line = lines[i]?.trim();
+            if (line === undefined)
+                break;
+            if (line.startsWith('//')) {
+                comments.unshift(line.replace(/^\/\/\s?/, ''));
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        return comments.length > 0 ? comments.join('\n') : 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/php.d.ts

@@ -0,0 +1,57 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for PHP source files
+ * Extracts: classes, interfaces, enums, traits, abstract classes,
+ *           public functions, public methods, public static methods
+ */
+export declare class PHPScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractImports;
+    /**
+     * Extract classes, interfaces, enums, traits, abstract classes
+     */
+    private extractTypes;
+    /**
+     * Extract the content between matching parentheses, handling nested parens.
+     * Starts at the given index which must point to an opening '('.
+     */
+    private extractParenContent;
+    /**
+     * Extract public methods (instance and static) from classes/interfaces/traits
+     * Skips private and protected methods
+     */
+    private extractMethods;
+    /**
+     * Extract standalone functions (not inside a class/interface/trait)
+     */
+    private extractFunctions;
+    /**
+     * Build a map of class/interface/trait/enum boundaries (start offset, end offset, name)
+     */
+    private getClassBoundaries;
+    /**
+     * Find the matching closing brace for an opening brace
+     */
+    private findMatchingBrace;
+    /**
+     * Find which class/interface/trait contains the given source offset
+     */
+    private findParentClass;
+    /**
+     * Parse PHP function parameters into Parameter objects
+     * Handles: type hints (?string, int|string, array), default values
+     */
+    private parsePHPParams;
+    /**
+     * Split parameter string by commas, respecting nested brackets
+     */
+    private splitParams;
+    private getLineNumber;
+    /**
+     * Extract PHPDoc block comment above a given line
+     */
+    private getDocComment;
+    private getSourceContext;
+}