skrypt-ai 0.4.2 → 0.6.0

package/dist/scanner/csharp.js

@@ -0,0 +1,421 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for C# source files
+ * Extracts: public classes, interfaces, enums, structs, records, methods
+ */
+export class CSharpScanner {
+    languages = ['csharp'];
+    canHandle(filePath) {
+        return (/\.cs$/.test(filePath) &&
+            !filePath.endsWith('Test.cs') &&
+            !filePath.endsWith('Tests.cs') &&
+            !filePath.includes('/Tests/') &&
+            !filePath.includes('/test/') &&
+            !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
+            const namespaceMatch = source.match(/^namespace\s+([\w.]+)/m);
+            const packageName = namespaceMatch?.[1] ?? 'unknown';
+            // Extract using statements for context
+            const imports = this.extractImports(source);
+            // Find all public types and methods
+            this.extractTypes(source, lines, filePath, packageName, imports, elements);
+            this.extractMethods(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'csharp',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'csharp',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    extractImports(source) {
+        const imports = [];
+        const regex = /^using\s+([^;]+);/gm;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+        return imports;
+    }
+    extractTypes(source, lines, filePath, packageName, imports, elements) {
+        // Match: public class/interface/enum/struct/record TypeName
+        // Optionally with generic params, base class, interfaces
+        const typeRegex = /^[ \t]*public\s+(?:(?:abstract|sealed|static|partial)\s+)*(?:(class|interface|enum|struct|record))\s+(\w+)\s*/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const kind = match[1];
+            const name = match[2];
+            if (!kind || !name)
+                continue;
+            // Extract generics with depth counting to handle nested generics
+            const afterName = match.index + match[0].length;
+            const generics = this.extractGenerics(source, afterName);
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            // For records with primary constructor params, extract them
+            let parameters = [];
+            if (kind === 'record') {
+                const recordParamMatch = source.slice(match.index).match(/public\s+(?:(?:abstract|sealed|static|partial)\s+)*record\s+\w+\s*(?:<[^>]+>)?\s*\(([^)]*)\)/);
+                if (recordParamMatch?.[1]) {
+                    parameters = this.parseCSharpParams(recordParamMatch[1]);
+                }
+            }
+            const signature = `public ${kind} ${name}${generics}`;
+            elements.push({
+                kind: 'class', // Using 'class' for all C# types
+                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) {
+        // We need to find which class each method belongs to.
+        // First, find all class/struct/record blocks and their ranges.
+        const classRanges = this.findClassRanges(source);
+        // Match public methods (instance or static, sync or async)
+        // Patterns:
+        //   public ReturnType MethodName(params)
+        //   public static ReturnType MethodName(params)
+        //   public async Task<T> MethodName(params)
+        //   public override ReturnType MethodName(params)
+        //   public virtual ReturnType MethodName(params)
+        // Exclude constructors (name matches class name) — we include them as methods
+        // Exclude property accessors, event handlers
+        const methodRegex = /^[ \t]*public\s+((?:(?:static|async|virtual|override|abstract|sealed|new)\s+)*)(\w+)/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const modifiers = match[1]?.trim() || '';
+            const baseReturnType = match[2];
+            if (!baseReturnType)
+                continue;
+            // After the base return type, extract any generics with depth counting
+            let pos = match.index + match[0].length;
+            const returnGenerics = this.extractGenerics(source, pos);
+            pos += returnGenerics.length;
+            const returnType = baseReturnType + returnGenerics;
+            // Skip whitespace
+            while (pos < source.length && (source[pos] === ' ' || source[pos] === '\t'))
+                pos++;
+            // Next token should be the method name (identifier)
+            const nameMatch = source.slice(pos).match(/^(\w+)\s*\(/);
+            if (!nameMatch || !nameMatch[1])
+                continue;
+            const name = nameMatch[1];
+            pos += nameMatch[0].length - 1; // position at '('
+            // Extract params up to the matching closing paren
+            const paramsStart = pos + 1;
+            let parenDepth = 1;
+            let parenPos = paramsStart;
+            while (parenPos < source.length && parenDepth > 0) {
+                if (source[parenPos] === '(')
+                    parenDepth++;
+                else if (source[parenPos] === ')')
+                    parenDepth--;
+                parenPos++;
+            }
+            const paramsStr = source.slice(paramsStart, parenPos - 1);
+            if (paramsStr === undefined)
+                continue;
+            // Skip type declarations (class, interface, enum, struct, record)
+            if (returnType === 'class' ||
+                returnType === 'interface' ||
+                returnType === 'enum' ||
+                returnType === 'struct' ||
+                returnType === 'record') {
+                continue;
+            }
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseCSharpParams(paramsStr);
+            const isAsync = modifiers.includes('async');
+            // Find parent class
+            const parentClass = this.findParentClass(match.index, classRanges);
+            const fullModifiers = modifiers ? `${modifiers} ` : '';
+            const signature = `public ${fullModifiers}${returnType} ${name}(${paramsStr})`;
+            elements.push({
+                kind: 'method',
+                name,
+                signature,
+                parameters,
+                returnType: returnType || undefined,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass,
+                isAsync,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+        // Also extract interface method signatures (no body, just declarations)
+        this.extractInterfaceMethods(source, lines, filePath, packageName, imports, elements, classRanges);
+    }
+    extractInterfaceMethods(source, lines, filePath, packageName, imports, elements, classRanges) {
+        // Interface methods don't have access modifiers in C#
+        // They look like: ReturnType MethodName(params);
+        // We only extract these inside interface blocks
+        const interfaceRanges = classRanges.filter(r => r.kind === 'interface');
+        for (const range of interfaceRanges) {
+            const body = source.slice(range.bodyStart, range.bodyEnd);
+            const methodRegex = /^[ \t]*(\w+)/gm;
+            let match;
+            while ((match = methodRegex.exec(body)) !== null) {
+                const baseReturnType = match[1];
+                if (!baseReturnType)
+                    continue;
+                // Skip lines that look like properties or non-method declarations
+                if (baseReturnType === 'get' || baseReturnType === 'set' || baseReturnType === '//' || baseReturnType === '///')
+                    continue;
+                // Extract generics for return type
+                let pos = match.index + match[0].length;
+                const returnGenerics = this.extractGenerics(body, pos);
+                pos += returnGenerics.length;
+                const returnType = baseReturnType + returnGenerics;
+                // Skip whitespace
+                while (pos < body.length && (body[pos] === ' ' || body[pos] === '\t'))
+                    pos++;
+                // Next should be method name followed by '('
+                const nameMatch = body.slice(pos).match(/^(\w+)\s*\(/);
+                if (!nameMatch || !nameMatch[1])
+                    continue;
+                const name = nameMatch[1];
+                pos += nameMatch[0].length - 1; // position at '('
+                // Extract params
+                const paramsStart = pos + 1;
+                let parenDepth = 1;
+                let parenPos = paramsStart;
+                while (parenPos < body.length && parenDepth > 0) {
+                    if (body[parenPos] === '(')
+                        parenDepth++;
+                    else if (body[parenPos] === ')')
+                        parenDepth--;
+                    parenPos++;
+                }
+                const paramsStr = body.slice(paramsStart, parenPos - 1);
+                // Must end with semicolon (interface method declaration)
+                const afterParen = body.slice(parenPos - 1).match(/^\)\s*;/);
+                if (!afterParen)
+                    continue;
+                if (paramsStr === undefined)
+                    continue;
+                const absoluteIndex = range.bodyStart + match.index;
+                const lineNumber = this.getLineNumber(source, absoluteIndex);
+                const docstring = this.getDocComment(lines, lineNumber - 1);
+                const parameters = this.parseCSharpParams(paramsStr);
+                const signature = `${returnType} ${name}(${paramsStr})`;
+                elements.push({
+                    kind: 'method',
+                    name,
+                    signature,
+                    parameters,
+                    returnType: returnType || undefined,
+                    docstring,
+                    filePath,
+                    lineNumber,
+                    parentClass: range.name,
+                    isAsync: false,
+                    isExported: true,
+                    isPublic: true,
+                    imports,
+                    packageName,
+                    sourceContext: this.getSourceContext(lines, lineNumber)
+                });
+            }
+        }
+    }
+    findClassRanges(source) {
+        const ranges = [];
+        const typeRegex = /^[ \t]*public\s+(?:(?:abstract|sealed|static|partial)\s+)*(?:(class|interface|enum|struct|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
+            // But first check if a semicolon comes before the brace (e.g., single-line records)
+            const afterMatchStart = match.index + match[0].length;
+            const afterMatch = source.indexOf('{', afterMatchStart);
+            if (afterMatch === -1)
+                continue;
+            const semicolonBefore = source.indexOf(';', afterMatchStart);
+            if (semicolonBefore !== -1 && semicolonBefore < afterMatch)
+                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;
+    }
+    findParentClass(index, classRanges) {
+        for (const range of classRanges) {
+            if (index > range.bodyStart && index < range.bodyEnd) {
+                return range.name;
+            }
+        }
+        return undefined;
+    }
+    parseCSharpParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Remove parameter modifiers: ref, out, in, params, this
+            let cleaned = trimmed.replace(/^(?:ref|out|in|params|this)\s+/, '');
+            // Format: "Type name" or "Type name = default"
+            const defaultMatch = cleaned.match(/^(.+?)\s*=\s*(.+)$/);
+            let defaultValue;
+            if (defaultMatch) {
+                cleaned = defaultMatch[1] ?? cleaned;
+                defaultValue = defaultMatch[2];
+            }
+            // Split into type and name: last word is name, rest is type
+            const lastSpace = cleaned.lastIndexOf(' ');
+            if (lastSpace > 0) {
+                const type = cleaned.slice(0, lastSpace).trim();
+                const name = cleaned.slice(lastSpace + 1).trim();
+                params.push({ name, type, default: defaultValue });
+            }
+            else {
+                // Just a name or type
+                params.push({ name: cleaned, 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) {
+        const comments = [];
+        let i = lineIndex - 1;
+        while (i >= 0) {
+            const lineContent = lines[i];
+            if (!lineContent)
+                break;
+            const line = lineContent.trim();
+            if (line.startsWith('///')) {
+                // XML doc comment line
+                let content = line.replace(/^\/\/\/\s?/, '');
+                // Strip XML tags like <summary>, </summary>, <param>, <returns>
+                content = content
+                    .replace(/<\/?summary>/g, '')
+                    .replace(/<\/?remarks>/g, '')
+                    .replace(/<\/?returns>/g, '')
+                    .replace(/<param\s+name="[^"]*">/g, '')
+                    .replace(/<\/param>/g, '')
+                    .trim();
+                if (content) {
+                    comments.unshift(content);
+                }
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else if (line.startsWith('[') && line.endsWith(']')) {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        return comments.length > 0 ? comments.join('\n') : undefined;
+    }
+    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 '';
+    }
+    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/index.js

@@ -1,9 +1,15 @@
 import { readdir, stat } from 'fs/promises';
-import { join, extname, parse as parsePath } from 'path';
+import { join, parse as parsePath } from 'path';
 import { PythonScanner } from './python.js';
 import { TypeScriptScanner } from './typescript.js';
 import { GoScanner } from './go.js';
 import { RustScanner } from './rust.js';
+import { JavaScanner } from './java.js';
+import { CSharpScanner } from './csharp.js';
+import { PHPScanner } from './php.js';
+import { KotlinScanner } from './kotlin.js';
+import { SwiftScanner } from './swift.js';
+import { RubyScanner } from './ruby.js';
 export * from './types.js';
 export * from './content-type.js';
 // All available scanners
@@ -12,6 +18,12 @@ const SCANNERS = [
     new TypeScriptScanner(),
     new GoScanner(),
     new RustScanner(),
+    new JavaScanner(),
+    new CSharpScanner(),
+    new PHPScanner(),
+    new KotlinScanner(),
+    new SwiftScanner(),
+    new RubyScanner(),
 ];
 /**
  * Get the appropriate scanner for a file
@@ -24,25 +36,30 @@ function getScannerForFile(filePath) {
     }
     return null;
 }
+/**
+ * Convert a glob pattern to a RegExp for proper matching.
+ * Supports: ** (any path), * (any segment), ? (any char)
+ */
+function globToRegex(pattern) {
+    // Normalize separators
+    let re = pattern.replace(/\\/g, '/');
+    // Escape regex special chars except * and ?
+    re = re.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // Convert glob tokens to regex
+    re = re.replace(/\*\*/g, '\0GLOBSTAR\0');
+    re = re.replace(/\*/g, '[^/]*');
+    re = re.replace(/\?/g, '[^/]');
+    re = re.replace(/\0GLOBSTAR\0/g, '.*');
+    return new RegExp(`(^|/)${re}($|/)`);
+}
 /**
  * Check if a path should be excluded based on patterns
  */
 function shouldExclude(filePath, excludePatterns) {
+    const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of excludePatterns) {
-        // Simple glob matching for common patterns
-        if (pattern.includes('**')) {
-            const parts = pattern.split('**');
-            if (parts.length === 2) {
-                const [prefix, suffix] = parts;
-                const prefixMatch = !prefix || filePath.includes(prefix.replace(/^\//, '').replace(/\/$/, ''));
-                const suffixMatch = !suffix || filePath.includes(suffix.replace(/^\//, '').replace(/\/$/, ''));
-                if (prefixMatch && suffixMatch)
-                    return true;
-            }
-        }
-        else if (filePath.includes(pattern.replace(/\*/g, ''))) {
+        if (globToRegex(pattern).test(normalized))
             return true;
-        }
     }
     return false;
 }
@@ -52,31 +69,39 @@ function shouldExclude(filePath, excludePatterns) {
 function shouldInclude(filePath, includePatterns) {
     if (includePatterns.length === 0)
         return true;
-    const ext = extname(filePath);
+    const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of includePatterns) {
-        // Match extension patterns like **/*.py
-        if (pattern.includes('*')) {
-            const extPattern = pattern.split('*').pop() || '';
-            if (ext === extPattern)
-                return true;
-        }
+        if (globToRegex(pattern).test(normalized))
+            return true;
     }
     return false;
 }
+const MAX_SCAN_DEPTH = 30;
+const MAX_SCAN_FILES = 10000;
 /**
  * Recursively find all files in a directory
  */
 async function findFiles(dir, include, exclude) {
     const files = [];
-    async function walk(currentDir) {
+    async function walk(currentDir, depth) {
+        if (depth > MAX_SCAN_DEPTH)
+            return;
+        if (files.length >= MAX_SCAN_FILES)
+            return;
         const entries = await readdir(currentDir, { withFileTypes: true });
         for (const entry of entries) {
+            if (files.length >= MAX_SCAN_FILES)
+                return;
             const fullPath = join(currentDir, entry.name);
             if (shouldExclude(fullPath, exclude)) {
                 continue;
             }
+            // Skip symlinks to prevent infinite loops and path escape
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
             if (entry.isDirectory()) {
-                await walk(fullPath);
+                await walk(fullPath, depth + 1);
             }
             else if (entry.isFile()) {
                 if (shouldInclude(fullPath, include) && getScannerForFile(fullPath)) {
@@ -85,15 +110,15 @@ async function findFiles(dir, include, exclude) {
             }
         }
     }
-    await walk(dir);
+    await walk(dir, 0);
     return files;
 }
 /**
  * Scan a directory (or single file) for all API elements
  */
 export async function scanDirectory(dir, options = {}) {
-    const include = options.include || ['**/*.py', '**/*.ts', '**/*.js', '**/*.go', '**/*.rs'];
-    const exclude = options.exclude || ['**/node_modules/**', '**/__pycache__/**', '**/dist/**'];
+    const include = options.include || ['**/*.py', '**/*.ts', '**/*.js', '**/*.go', '**/*.rs', '**/*.java', '**/*.cs', '**/*.php', '**/*.kt', '**/*.kts', '**/*.swift', '**/*.rb'];
+    const exclude = options.exclude || ['**/node_modules/**', '**/__pycache__/**', '**/dist/**', '**/target/**', '**/vendor/**', '**/build/**', '**/bin/**', '**/obj/**', '**/.build/**'];
     // Check if input is a file or directory
     const stats = await stat(dir);
     let files;
@@ -139,6 +164,8 @@ export async function scanFile(filePath) {
         const langMap = {
             ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
             py: 'python', go: 'go', rs: 'rust',
+            java: 'java', cs: 'csharp', php: 'php',
+            kt: 'kotlin', kts: 'kotlin', swift: 'swift', rb: 'ruby',
         };
         const language = langMap[ext] ?? 'typescript';
         return {

package/dist/scanner/java.d.ts

@@ -0,0 +1,39 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Java source files
+ * Extracts: public classes, public methods, public static methods
+ */
+export declare class JavaScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractPackage;
+    private extractImports;
+    /**
+     * Extracts the full generics string starting at startIndex by counting `<>` depth.
+     * Returns empty string if source[startIndex] is not '<'.
+     */
+    private extractGenerics;
+    private extractClasses;
+    private extractMethods;
+    /**
+     * Extracts interface methods that don't have explicit `public` modifier.
+     * In Java, interface methods are implicitly public.
+     */
+    private extractInterfaceMethods;
+    /**
+     * Finds all class/interface/enum/record declarations and their brace-delimited ranges.
+     */
+    private findClassRanges;
+    private findMatchingBrace;
+    /**
+     * Finds the innermost class that contains the given source index,
+     * using brace-depth-aware class ranges.
+     */
+    private findParentClass;
+    private parseParams;
+    private splitParams;
+    private getLineNumber;
+    private getJavadoc;
+    private getSourceContext;
+}