skrypt-ai 0.5.0 → 0.6.0

package/dist/scanner/php.js

@@ -0,0 +1,351 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for PHP source files
+ * Extracts: classes, interfaces, enums, traits, abstract classes,
+ *           public functions, public methods, public static methods
+ */
+export class PHPScanner {
+    languages = ['php'];
+    canHandle(filePath) {
+        return (/\.php$/.test(filePath) &&
+            !filePath.includes('Test.php') &&
+            !filePath.includes('/tests/') &&
+            !filePath.includes('/test/'));
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Extract namespace as package name
+            const namespaceMatch = source.match(/^namespace\s+([\w\\]+)\s*;/m);
+            const packageName = namespaceMatch?.[1] ?? 'global';
+            // Extract use/import statements for context
+            const imports = this.extractImports(source);
+            // Find all public API elements
+            this.extractTypes(source, lines, filePath, packageName, imports, elements);
+            this.extractMethods(source, lines, filePath, packageName, imports, elements);
+            this.extractFunctions(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'php',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'php',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    extractImports(source) {
+        const imports = [];
+        const useMatches = source.matchAll(/^use\s+([\w\\]+)(?:\s+as\s+\w+)?;/gm);
+        for (const m of useMatches) {
+            if (m[1])
+                imports.push(m[1]);
+        }
+        return imports;
+    }
+    /**
+     * Extract classes, interfaces, enums, traits, abstract classes
+     */
+    extractTypes(source, lines, filePath, packageName, imports, elements) {
+        // Match: class, abstract class, final class, readonly class, final readonly class, interface, enum, trait
+        const typeRegex = /^(?:(?:abstract|final|readonly)\s+)*(?:class|interface|enum|trait)\s+(\w+)/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            const fullMatch = match[0];
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = fullMatch.trim();
+            elements.push({
+                kind: 'class',
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    /**
+     * Extract the content between matching parentheses, handling nested parens.
+     * Starts at the given index which must point to an opening '('.
+     */
+    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;
+    }
+    /**
+     * Extract public methods (instance and static) from classes/interfaces/traits
+     * Skips private and protected methods
+     */
+    extractMethods(source, lines, filePath, packageName, imports, elements) {
+        // First, build a map of class boundaries to determine parentClass
+        const classBoundaries = this.getClassBoundaries(source);
+        // Match public methods up to and including the opening paren
+        // Supports: public function, public static function, public final function,
+        //           final public function, final public static function, etc.
+        const methodRegex = /^[ \t]+(?:final\s+)?public\s+(?:(?:static|abstract|final)\s+)*function\s+(\w+)\s*\(/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            // Extract params using balanced-paren helper
+            const openParenIndex = match.index + match[0].length - 1;
+            const paramsStr = this.extractParenContent(source, openParenIndex);
+            if (paramsStr === null)
+                continue;
+            // Look for return type after the closing paren
+            const closeParenIndex = openParenIndex + 1 + paramsStr.length; // index of ')'
+            const afterParen = source.slice(closeParenIndex + 1);
+            const returnTypeMatch = afterParen.match(/^\s*:\s*([\w\\|?]+)/);
+            const returnType = returnTypeMatch?.[1]?.trim() || undefined;
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parsePHPParams(paramsStr);
+            const parentClass = this.findParentClass(match.index, classBoundaries);
+            // Build signature including params and return type
+            const sigBase = match[0] + paramsStr + ')';
+            const signature = (returnType ? sigBase + ': ' + returnType : sigBase).trim();
+            elements.push({
+                kind: 'method',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    /**
+     * Extract standalone functions (not inside a class/interface/trait)
+     */
+    extractFunctions(source, lines, filePath, packageName, imports, elements) {
+        const classBoundaries = this.getClassBoundaries(source);
+        // Match top-level functions up to and including the opening paren
+        // Must start at the beginning of a line (no leading whitespace = not a method)
+        const funcRegex = /^function\s+(\w+)\s*\(/gm;
+        let match;
+        while ((match = funcRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            // Skip if inside a class boundary
+            const parentClass = this.findParentClass(match.index, classBoundaries);
+            if (parentClass)
+                continue;
+            // Extract params using balanced-paren helper
+            const openParenIndex = match.index + match[0].length - 1;
+            const paramsStr = this.extractParenContent(source, openParenIndex);
+            if (paramsStr === null)
+                continue;
+            // Look for return type after the closing paren
+            const closeParenIndex = openParenIndex + 1 + paramsStr.length;
+            const afterParen = source.slice(closeParenIndex + 1);
+            const returnTypeMatch = afterParen.match(/^\s*:\s*([\w\\|?]+)/);
+            const returnType = returnTypeMatch?.[1]?.trim() || undefined;
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parsePHPParams(paramsStr);
+            // Build signature including params and return type
+            const sigBase = match[0] + paramsStr + ')';
+            const signature = (returnType ? sigBase + ': ' + returnType : sigBase).trim();
+            elements.push({
+                kind: 'function',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    /**
+     * Build a map of class/interface/trait/enum boundaries (start offset, end offset, name)
+     */
+    getClassBoundaries(source) {
+        const boundaries = [];
+        const typeRegex = /^(?:(?:abstract|final|readonly)\s+)*(?:class|interface|enum|trait)\s+(\w+)[^{]*\{/gm;
+        let match;
+        while ((match = typeRegex.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.findMatchingBrace(source, braceStart);
+            boundaries.push({ name, start, end });
+        }
+        return boundaries;
+    }
+    /**
+     * Find the matching closing brace for an opening brace
+     */
+    findMatchingBrace(source, openPos) {
+        let depth = 0;
+        for (let i = openPos; i < source.length; i++) {
+            if (source[i] === '{')
+                depth++;
+            else if (source[i] === '}') {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return source.length;
+    }
+    /**
+     * Find which class/interface/trait contains the given source offset
+     */
+    findParentClass(offset, boundaries) {
+        for (const b of boundaries) {
+            if (offset > b.start && offset < b.end) {
+                return b.name;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Parse PHP function parameters into Parameter objects
+     * Handles: type hints (?string, int|string, array), default values
+     */
+    parsePHPParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // PHP param format: [?]Type $name [= default]
+            // or: Type|Type2 $name
+            // or: $name (no type hint)
+            const paramMatch = trimmed.match(/^((?:[\w\\|?]+\s+)?)(\$\w+)(?:\s*=\s*(.+))?$/);
+            if (paramMatch) {
+                const type = paramMatch[1]?.trim() || undefined;
+                const name = paramMatch[2]?.replace(/^\$/, '') ?? '';
+                const defaultValue = paramMatch[3]?.trim() || undefined;
+                if (name) {
+                    params.push({ name, type, default: defaultValue });
+                }
+            }
+        }
+        return params;
+    }
+    /**
+     * Split parameter string by commas, respecting nested brackets
+     */
+    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;
+    }
+    /**
+     * Extract PHPDoc block comment above a given line
+     */
+    getDocComment(lines, lineIndex) {
+        // Look for a closing */ above the declaration line
+        let i = lineIndex - 1;
+        // Skip blank lines and PHP 8 attribute lines (#[...])
+        while (i >= 0) {
+            const trimmed = lines[i]?.trim() ?? '';
+            if (trimmed === '') {
+                i--;
+            }
+            else if (trimmed.startsWith('#[')) {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        if (i < 0)
+            return undefined;
+        const closeLine = lines[i];
+        if (!closeLine || !closeLine.trim().endsWith('*/'))
+            return undefined;
+        // Walk up to find the opening /**
+        let start = i;
+        while (start >= 0 && !lines[start]?.includes('/**')) {
+            start--;
+        }
+        if (start < 0 || !lines[start]?.includes('/**'))
+            return undefined;
+        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;
+    }
+    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/ruby.d.ts

@@ -0,0 +1,36 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Ruby source files
+ * Extracts: classes, modules, methods (public only)
+ */
+export declare class RubyScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractImports;
+    private extractModuleNesting;
+    private extractClasses;
+    private extractModules;
+    /**
+     * Get the body of a module/class starting at the given source index.
+     * Returns the text between the opening line and its matching `end`, or null.
+     */
+    private getModuleBody;
+    private extractMethods;
+    /**
+     * Build a map of lineNumber → visibility for every `def` line.
+     * Ruby's `private` / `protected` markers apply to all subsequent defs
+     * within the same class/module scope until another visibility marker.
+     */
+    private buildVisibilityMap;
+    private findParentClass;
+    private parseRubyParams;
+    private splitParams;
+    private getDocComment;
+    /**
+     * Extract @return type from YARD comments above a method.
+     */
+    private extractReturnType;
+    private getLineNumber;
+    private getSourceContext;
+}