skrypt-ai 0.5.0 → 0.6.0

package/dist/scanner/ruby.js

@@ -0,0 +1,431 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Ruby source files
+ * Extracts: classes, modules, methods (public only)
+ */
+export class RubyScanner {
+    languages = ['ruby'];
+    canHandle(filePath) {
+        return (/\.rb$/.test(filePath) &&
+            !/_test\.rb$/.test(filePath) &&
+            !/_spec\.rb$/.test(filePath) &&
+            !/(^|\/)test\//.test(filePath) &&
+            !/(^|\/)spec\//.test(filePath));
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Extract module nesting as packageName
+            const packageName = this.extractModuleNesting(source);
+            // Extract imports (require / require_relative)
+            const imports = this.extractImports(source);
+            // Extract classes
+            this.extractClasses(source, lines, filePath, packageName, imports, elements);
+            // Extract modules (non-wrapping, constant-holder modules)
+            this.extractModules(source, lines, filePath, packageName, imports, elements);
+            // Extract methods
+            this.extractMethods(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'ruby',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'ruby',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Imports
+    // ---------------------------------------------------------------------------
+    extractImports(source) {
+        const imports = [];
+        const regex = /^(?:require|require_relative)\s+['"]([^'"]+)['"]/gm;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+        return imports;
+    }
+    // ---------------------------------------------------------------------------
+    // Module nesting  →  "App::Services"
+    // ---------------------------------------------------------------------------
+    extractModuleNesting(source) {
+        const modules = [];
+        const lines = source.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            const match = trimmed.match(/^module\s+(\w+)/);
+            if (match?.[1]) {
+                modules.push(match[1]);
+            }
+            // Stop at first non-module declaration (class, def, end, or constant)
+            if (/^(class|def|end)\s/.test(trimmed) || /^[A-Z]\w*\s*=/.test(trimmed))
+                break;
+        }
+        return modules.length > 0 ? modules.join('::') : 'unknown';
+    }
+    // ---------------------------------------------------------------------------
+    // Classes
+    // ---------------------------------------------------------------------------
+    extractClasses(source, lines, filePath, packageName, imports, elements) {
+        const classRegex = /^\s*class\s+(\w+)(?:\s*<\s*(\w+))?/gm;
+        let match;
+        while ((match = classRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            const superclass = match[2] ?? '';
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = superclass
+                ? `class ${name} < ${superclass}`
+                : `class ${name}`;
+            elements.push({
+                kind: 'class',
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Modules (constant-holder / namespace modules that don't wrap classes)
+    // ---------------------------------------------------------------------------
+    extractModules(source, lines, filePath, packageName, imports, elements) {
+        const moduleRegex = /^\s*module\s+(\w+)/gm;
+        let match;
+        while ((match = moduleRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            // Only emit modules that contain constants (FOO = ...) and do NOT
+            // contain class/def definitions — i.e. "leaf" modules.
+            const lineNumber = this.getLineNumber(source, match.index);
+            const body = this.getModuleBody(source, match.index);
+            if (body === null)
+                continue;
+            // Skip modules that contain class or def declarations (wrapper modules)
+            if (/^\s*(?:class|def)\s+/m.test(body))
+                continue;
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = `module ${name}`;
+            elements.push({
+                kind: 'class', // Using 'class' for Ruby modules (same as Go types)
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    /**
+     * 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.
+     */
+    getModuleBody(source, startIndex) {
+        const rest = source.slice(startIndex);
+        const firstNewline = rest.indexOf('\n');
+        if (firstNewline === -1)
+            return null;
+        let depth = 1;
+        const bodyLines = rest.slice(firstNewline + 1).split('\n');
+        const collected = [];
+        for (const line of bodyLines) {
+            const trimmed = line.trim();
+            // Count opens: class, module, def, do, begin, if/unless/while/for/case (as statement openers)
+            if (/^(?:class|module|def|begin|if|unless|while|for|case|do)\b/.test(trimmed) ||
+                /\bdo\s*(?:\|[^|]*\|)?\s*$/.test(trimmed)) {
+                depth++;
+            }
+            if (trimmed === 'end' || /^end\b/.test(trimmed)) {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+            collected.push(line);
+        }
+        return collected.join('\n');
+    }
+    // ---------------------------------------------------------------------------
+    // Methods
+    // ---------------------------------------------------------------------------
+    extractMethods(source, lines, filePath, packageName, imports, elements) {
+        // Build visibility map: for each line, is it under a `private` or `protected` marker?
+        const visibilityMap = this.buildVisibilityMap(lines);
+        // Match: def method_name(params)  and  def self.method_name(params)
+        const methodRegex = /^\s*def\s+(self\.)?(\w+[?!=]?)(?:\s*\(([^)]*)\))?/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const isSelfMethod = !!match[1];
+            const name = match[2];
+            const paramsStr = match[3] ?? '';
+            if (!name)
+                continue;
+            // Skip initialize (constructor internals)
+            if (name === 'initialize')
+                continue;
+            const lineNumber = this.getLineNumber(source, match.index);
+            // Check visibility — skip private / protected
+            const visibility = visibilityMap.get(lineNumber);
+            if (visibility === 'private' || visibility === 'protected')
+                continue;
+            // Handle inline `private def method_name` / `protected def method_name`
+            const fullLine = lines[lineNumber - 1];
+            if (fullLine) {
+                const trimmedLine = fullLine.trim();
+                if (trimmedLine.startsWith('private ') || trimmedLine.startsWith('protected '))
+                    continue;
+            }
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseRubyParams(paramsStr);
+            const parentClass = this.findParentClass(source, match.index);
+            const returnType = this.extractReturnType(lines, lineNumber - 1);
+            const sig = isSelfMethod
+                ? `def self.${name}(${paramsStr})`
+                : `def ${name}(${paramsStr})`;
+            elements.push({
+                kind: parentClass ? 'method' : 'function',
+                name,
+                signature: sig,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Visibility tracking
+    // ---------------------------------------------------------------------------
+    /**
+     * 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.
+     */
+    buildVisibilityMap(lines) {
+        const map = new Map();
+        const scopeStack = [{ kind: 'module', visibility: 'public' }];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            const trimmed = line.trim();
+            // Opening a new class/module scope
+            if (/^class\s+/.test(trimmed) || /^module\s+/.test(trimmed)) {
+                scopeStack.push({ kind: 'class', visibility: 'public' });
+                continue;
+            }
+            // Opening a def scope (we track it so `end` doesn't pop class/module)
+            if (/^def\s+/.test(trimmed)) {
+                // Record visibility before pushing def scope
+                const parentScope = scopeStack[scopeStack.length - 1];
+                map.set(i + 1, parentScope?.visibility ?? 'public');
+                scopeStack.push({ kind: 'def', visibility: parentScope?.visibility ?? 'public' });
+                continue;
+            }
+            // End of scope
+            if (trimmed === 'end') {
+                if (scopeStack.length > 1)
+                    scopeStack.pop();
+                continue;
+            }
+            // Visibility marker (bare keyword on its own line)
+            if (/^(private|protected|public)\s*$/.test(trimmed)) {
+                const scope = scopeStack[scopeStack.length - 1];
+                if (scope && scope.kind !== 'def')
+                    scope.visibility = trimmed;
+                continue;
+            }
+        }
+        return map;
+    }
+    // ---------------------------------------------------------------------------
+    // Parent class lookup
+    // ---------------------------------------------------------------------------
+    findParentClass(source, index) {
+        const before = source.slice(0, index);
+        const classMatches = [...before.matchAll(/class\s+(\w+)/g)];
+        if (classMatches.length === 0)
+            return undefined;
+        // Verify the class scope is still open (not yet closed by `end`)
+        const lastClassMatch = classMatches[classMatches.length - 1];
+        const className = lastClassMatch[1];
+        const afterClass = source.slice(lastClassMatch.index + lastClassMatch[0].length, index);
+        // Rough depth check: count class/module/def opens vs `end` closes
+        let depth = 1;
+        const scopeLines = afterClass.split('\n');
+        for (const scopeLine of scopeLines) {
+            const t = scopeLine.trim();
+            if (/^(?:class|module|def)\s+/.test(t))
+                depth++;
+            if (t === 'end')
+                depth--;
+            if (depth <= 0)
+                break;
+        }
+        return depth > 0 ? className : undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // Parameter parsing
+    // ---------------------------------------------------------------------------
+    parseRubyParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Block param: &block
+            if (trimmed.startsWith('&')) {
+                params.push({ name: trimmed.slice(1), type: 'block' });
+                continue;
+            }
+            // Double-splat: **kwargs
+            if (trimmed.startsWith('**')) {
+                params.push({ name: trimmed.slice(2), type: '**kwargs' });
+                continue;
+            }
+            // Splat: *args
+            if (trimmed.startsWith('*')) {
+                params.push({ name: trimmed.slice(1), type: '*args' });
+                continue;
+            }
+            // Keyword arg with default: name: default
+            const kwDefault = trimmed.match(/^(\w+):\s*(.+)$/);
+            if (kwDefault?.[1] && kwDefault[2] !== undefined) {
+                params.push({ name: kwDefault[1], type: 'keyword', default: kwDefault[2] });
+                continue;
+            }
+            // Keyword arg (required): name:
+            const kwRequired = trimmed.match(/^(\w+):$/);
+            if (kwRequired?.[1]) {
+                params.push({ name: kwRequired[1], type: 'keyword' });
+                continue;
+            }
+            // Positional with default: name = value
+            const posDefault = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+            if (posDefault?.[1] && posDefault[2] !== undefined) {
+                params.push({ name: posDefault[1], default: posDefault[2] });
+                continue;
+            }
+            // Plain positional
+            params.push({ name: trimmed });
+        }
+        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;
+    }
+    // ---------------------------------------------------------------------------
+    // Doc comments (YARD and plain #)
+    // ---------------------------------------------------------------------------
+    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('#')) {
+                comments.unshift(line.replace(/^#\s?/, ''));
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        return comments.length > 0 ? comments.join('\n') : undefined;
+    }
+    /**
+     * Extract @return type from YARD comments above a method.
+     */
+    extractReturnType(lines, lineIndex) {
+        let i = lineIndex - 1;
+        while (i >= 0) {
+            const lineContent = lines[i];
+            if (!lineContent)
+                break;
+            const line = lineContent.trim();
+            if (line.startsWith('#')) {
+                const returnMatch = line.match(/@return\s+\[([^\]]+)\]/);
+                if (returnMatch?.[1])
+                    return returnMatch[1];
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        return undefined;
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    getLineNumber(source, index) {
+        return source.slice(0, index).split('\n').length;
+    }
+    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/swift.d.ts

@@ -0,0 +1,25 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Swift source files
+ * Extracts: public/open classes, structs, enums, protocols, actors, functions, methods
+ */
+export declare class SwiftScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private inferModuleName;
+    private extractImports;
+    private extractTypes;
+    private extractParenContent;
+    private extractTrailingSignature;
+    private extractTopLevelFunctions;
+    private extractMethods;
+    private buildSignature;
+    private extractBlock;
+    private parseSwiftParams;
+    private findDefaultValueSplit;
+    private splitParams;
+    private getLineNumber;
+    private getDocComment;
+    private getSourceContext;
+}