skrypt-ai 0.1.0

package/dist/scanner/python.js

@@ -0,0 +1,57 @@
+import { spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PARSER_SCRIPT = join(__dirname, 'python_parser.py');
+export class PythonScanner {
+    languages = ['python'];
+    canHandle(filePath) {
+        return filePath.endsWith('.py');
+    }
+    async scanFile(filePath) {
+        return new Promise((resolve) => {
+            const proc = spawn('python3', [PARSER_SCRIPT, filePath], {
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                if (code !== 0 || stderr) {
+                    resolve({
+                        filePath,
+                        language: 'python',
+                        elements: [],
+                        errors: [stderr || `Python parser exited with code ${code}`]
+                    });
+                    return;
+                }
+                try {
+                    const result = JSON.parse(stdout);
+                    resolve(result);
+                }
+                catch (e) {
+                    resolve({
+                        filePath,
+                        language: 'python',
+                        elements: [],
+                        errors: [`Failed to parse output: ${e}`]
+                    });
+                }
+            });
+            proc.on('error', (err) => {
+                resolve({
+                    filePath,
+                    language: 'python',
+                    elements: [],
+                    errors: [`Failed to spawn Python: ${err.message}`]
+                });
+            });
+        });
+    }
+}

package/dist/scanner/python_parser.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Extract API elements from Python files using the ast module.
+Called by the Node.js scanner via subprocess.
+Outputs JSON to stdout.
+"""
+
+import ast
+import json
+import sys
+from typing import Any
+
+
+def get_docstring(node: ast.AST) -> str | None:
+    """Extract docstring from a node if present."""
+    return ast.get_docstring(node)
+
+
+def get_type_annotation(annotation: ast.AST | None) -> str | None:
+    """Convert type annotation AST to string."""
+    if annotation is None:
+        return None
+    return ast.unparse(annotation)
+
+
+def get_default_value(default: ast.AST | None) -> str | None:
+    """Convert default value AST to string."""
+    if default is None:
+        return None
+    return ast.unparse(default)
+
+
+def extract_parameters(args: ast.arguments) -> list[dict[str, Any]]:
+    """Extract parameters from function arguments."""
+    params = []
+
+    # Calculate defaults offset (defaults align to end of args)
+    num_args = len(args.args)
+    num_defaults = len(args.defaults)
+    defaults_offset = num_args - num_defaults
+
+    for i, arg in enumerate(args.args):
+        # Skip 'self' and 'cls' for methods
+        if arg.arg in ('self', 'cls'):
+            continue
+
+        param = {
+            'name': arg.arg,
+            'type': get_type_annotation(arg.annotation),
+        }
+
+        # Check if this arg has a default
+        default_idx = i - defaults_offset
+        if default_idx >= 0 and default_idx < len(args.defaults):
+            param['default'] = get_default_value(args.defaults[default_idx])
+
+        params.append(param)
+
+    # Handle *args
+    if args.vararg:
+        params.append({
+            'name': f'*{args.vararg.arg}',
+            'type': get_type_annotation(args.vararg.annotation),
+        })
+
+    # Handle keyword-only args
+    for i, arg in enumerate(args.kwonlyargs):
+        param = {
+            'name': arg.arg,
+            'type': get_type_annotation(arg.annotation),
+        }
+        if i < len(args.kw_defaults) and args.kw_defaults[i]:
+            param['default'] = get_default_value(args.kw_defaults[i])
+        params.append(param)
+
+    # Handle **kwargs
+    if args.kwarg:
+        params.append({
+            'name': f'**{args.kwarg.arg}',
+            'type': get_type_annotation(args.kwarg.annotation),
+        })
+
+    return params
+
+
+def build_signature(name: str, args: ast.arguments, returns: ast.AST | None, is_async: bool) -> str:
+    """Build the function signature as a string."""
+    params = []
+
+    for arg in args.args:
+        p = arg.arg
+        if arg.annotation:
+            p += f': {ast.unparse(arg.annotation)}'
+        params.append(p)
+
+    if args.vararg:
+        p = f'*{args.vararg.arg}'
+        if args.vararg.annotation:
+            p += f': {ast.unparse(args.vararg.annotation)}'
+        params.append(p)
+
+    for i, arg in enumerate(args.kwonlyargs):
+        p = arg.arg
+        if arg.annotation:
+            p += f': {ast.unparse(arg.annotation)}'
+        if i < len(args.kw_defaults) and args.kw_defaults[i]:
+            p += f' = {ast.unparse(args.kw_defaults[i])}'
+        params.append(p)
+
+    if args.kwarg:
+        p = f'**{args.kwarg.arg}'
+        if args.kwarg.annotation:
+            p += f': {ast.unparse(args.kwarg.annotation)}'
+        params.append(p)
+
+    sig = f"{'async ' if is_async else ''}def {name}({', '.join(params)})"
+    if returns:
+        sig += f' -> {ast.unparse(returns)}'
+
+    return sig
+
+
+def extract_function(node: ast.FunctionDef | ast.AsyncFunctionDef, file_path: str, parent_class: str | None = None) -> dict[str, Any]:
+    """Extract a function or method."""
+    is_async = isinstance(node, ast.AsyncFunctionDef)
+    is_method = parent_class is not None
+    is_public = not node.name.startswith('_') or node.name.startswith('__') and node.name.endswith('__')
+
+    return {
+        'kind': 'method' if is_method else 'function',
+        'name': node.name,
+        'signature': build_signature(node.name, node.args, node.returns, is_async),
+        'parameters': extract_parameters(node.args),
+        'returnType': get_type_annotation(node.returns),
+        'docstring': get_docstring(node),
+        'filePath': file_path,
+        'lineNumber': node.lineno,
+        'parentClass': parent_class,
+        'isAsync': is_async,
+        'isPublic': is_public,
+    }
+
+
+def extract_class(node: ast.ClassDef, file_path: str) -> list[dict[str, Any]]:
+    """Extract a class and its methods."""
+    elements = []
+    is_public = not node.name.startswith('_')
+
+    # Add the class itself
+    bases = [ast.unparse(b) for b in node.bases]
+    signature = f"class {node.name}"
+    if bases:
+        signature += f"({', '.join(bases)})"
+
+    elements.append({
+        'kind': 'class',
+        'name': node.name,
+        'signature': signature,
+        'parameters': [],  # Classes don't have parameters in signature
+        'docstring': get_docstring(node),
+        'filePath': file_path,
+        'lineNumber': node.lineno,
+        'isPublic': is_public,
+    })
+
+    # Extract methods
+    for item in node.body:
+        if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            # Skip private methods unless they're dunder methods
+            if item.name.startswith('_') and not (item.name.startswith('__') and item.name.endswith('__')):
+                continue
+            elements.append(extract_function(item, file_path, parent_class=node.name))
+
+    return elements
+
+
+def scan_file(file_path: str) -> dict[str, Any]:
+    """Scan a Python file and extract all API elements."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            source = f.read()
+
+        tree = ast.parse(source, filename=file_path)
+    except SyntaxError as e:
+        return {
+            'filePath': file_path,
+            'language': 'python',
+            'elements': [],
+            'errors': [f'Syntax error: {e}']
+        }
+    except Exception as e:
+        return {
+            'filePath': file_path,
+            'language': 'python',
+            'elements': [],
+            'errors': [str(e)]
+        }
+
+    elements = []
+
+    for node in ast.iter_child_nodes(tree):
+        # Top-level functions
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            # Skip private functions
+            if node.name.startswith('_') and not (node.name.startswith('__') and node.name.endswith('__')):
+                continue
+            elements.append(extract_function(node, file_path))
+
+        # Classes
+        elif isinstance(node, ast.ClassDef):
+            # Skip private classes
+            if node.name.startswith('_'):
+                continue
+            elements.extend(extract_class(node, file_path))
+
+    return {
+        'filePath': file_path,
+        'language': 'python',
+        'elements': elements,
+        'errors': []
+    }
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print(json.dumps({'error': 'Usage: python_parser.py <file_path>'}))
+        sys.exit(1)
+
+    result = scan_file(sys.argv[1])
+    print(json.dumps(result, indent=2))

package/dist/scanner/rust.d.ts

@@ -0,0 +1,23 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Rust source files
+ * Extracts: pub functions, pub structs, pub enums, impl blocks, traits
+ */
+export declare class RustScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private inferCrateName;
+    private extractUseStatements;
+    private extractFunctions;
+    private isTopLevelFn;
+    private extractStructsAndEnums;
+    private extractTraits;
+    private extractImplMethods;
+    private extractBlock;
+    private parseRustParams;
+    private splitParams;
+    private getLineNumber;
+    private getDocComment;
+    private getSourceContext;
+}

package/dist/scanner/rust.js

@@ -0,0 +1,304 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Rust source files
+ * Extracts: pub functions, pub structs, pub enums, impl blocks, traits
+ */
+export class RustScanner {
+    languages = ['rust'];
+    canHandle(filePath) {
+        return /\.rs$/.test(filePath) && !filePath.includes('/tests/');
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Infer crate/module name from path
+            const packageName = this.inferCrateName(filePath);
+            // Extract use statements for context
+            const imports = this.extractUseStatements(source);
+            // Find all pub items
+            this.extractFunctions(source, lines, filePath, packageName, imports, elements);
+            this.extractStructsAndEnums(source, lines, filePath, packageName, imports, elements);
+            this.extractTraits(source, lines, filePath, packageName, imports, elements);
+            this.extractImplMethods(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'rust',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'rust',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    inferCrateName(filePath) {
+        // Look for Cargo.toml parent or use directory name
+        const parts = filePath.split('/');
+        const srcIndex = parts.indexOf('src');
+        if (srcIndex > 0) {
+            return parts[srcIndex - 1];
+        }
+        return parts[parts.length - 2] || 'unknown';
+    }
+    extractUseStatements(source) {
+        const uses = [];
+        const regex = /^use\s+([^;]+);/gm;
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            uses.push(match[1]);
+        }
+        return uses;
+    }
+    extractFunctions(source, lines, filePath, packageName, imports, elements) {
+        // Match: pub fn function_name<generics>(params) -> ReturnType
+        // Also handles pub async fn, pub const fn, pub unsafe fn
+        const funcRegex = /^(\s*)(pub(?:\s+(?:async|const|unsafe))?\s+fn)\s+(\w+)\s*(<[^>]+>)?\s*\(([^)]*)\)\s*(->\s*[^{]+)?/gm;
+        let match;
+        while ((match = funcRegex.exec(source)) !== null) {
+            const indent = match[1];
+            // Skip if indented (inside impl block - handled separately)
+            if (indent.length > 0 && !this.isTopLevelFn(source, match.index))
+                continue;
+            const fnKeyword = match[2];
+            const name = match[3];
+            const generics = match[4] || '';
+            const paramsStr = match[5];
+            const returnPart = match[6]?.trim() || '';
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseRustParams(paramsStr);
+            const returnType = returnPart ? returnPart.replace(/^->\s*/, '').trim() : undefined;
+            const isAsync = fnKeyword.includes('async');
+            const signature = `${fnKeyword} ${name}${generics}(${paramsStr})${returnPart ? ' ' + returnPart : ''}`;
+            elements.push({
+                kind: 'function',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                isAsync,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    isTopLevelFn(source, index) {
+        // Check if we're inside an impl block by counting brace balance
+        const before = source.slice(0, index);
+        const braceBalance = (before.match(/\{/g) || []).length - (before.match(/\}/g) || []).length;
+        return braceBalance === 0;
+    }
+    extractStructsAndEnums(source, lines, filePath, packageName, imports, elements) {
+        // Match: pub struct StructName<generics> or pub enum EnumName
+        const typeRegex = /^pub\s+(struct|enum)\s+(\w+)\s*(<[^>]+>)?/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const kind = match[1];
+            const name = match[2];
+            const generics = match[3] || '';
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = `pub ${kind} ${name}${generics}`;
+            elements.push({
+                kind: 'class', // Using 'class' for Rust structs/enums
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 20)
+            });
+        }
+    }
+    extractTraits(source, lines, filePath, packageName, imports, elements) {
+        // Match: pub trait TraitName<generics>
+        const traitRegex = /^pub\s+trait\s+(\w+)\s*(<[^>]+>)?/gm;
+        let match;
+        while ((match = traitRegex.exec(source)) !== null) {
+            const name = match[1];
+            const generics = match[2] || '';
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = `pub trait ${name}${generics}`;
+            elements.push({
+                kind: 'class', // Using 'class' for traits
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    extractImplMethods(source, lines, filePath, packageName, imports, elements) {
+        // Find impl blocks and their methods
+        // Match: impl<generics> TypeName { ... }
+        // Or: impl<generics> Trait for TypeName { ... }
+        const implRegex = /impl\s*(<[^>]+>)?\s*(?:(\w+)\s+for\s+)?(\w+)(?:<[^>]+>)?\s*\{/g;
+        let implMatch;
+        while ((implMatch = implRegex.exec(source)) !== null) {
+            // implMatch[2] contains trait name if implementing a trait (for future use)
+            const typeName = implMatch[3];
+            const implStart = implMatch.index;
+            // Find the matching closing brace
+            const implBody = this.extractBlock(source, implStart + implMatch[0].length - 1);
+            if (!implBody)
+                continue;
+            // Extract pub fn methods from the impl body
+            const methodRegex = /^\s*(pub(?:\s+(?:async|const|unsafe))?\s+fn)\s+(\w+)\s*(<[^>]+>)?\s*\(([^)]*)\)\s*(->\s*[^{]+)?/gm;
+            let methodMatch;
+            while ((methodMatch = methodRegex.exec(implBody)) !== null) {
+                const fnKeyword = methodMatch[1];
+                const name = methodMatch[2];
+                const generics = methodMatch[3] || '';
+                const paramsStr = methodMatch[4];
+                const returnPart = methodMatch[5]?.trim() || '';
+                const bodyIndex = implBody.indexOf(methodMatch[0]);
+                const fullIndex = implStart + implMatch[0].length + bodyIndex;
+                const lineNumber = this.getLineNumber(source, fullIndex);
+                const docstring = this.getDocComment(lines, lineNumber - 1);
+                const parameters = this.parseRustParams(paramsStr);
+                const returnType = returnPart ? returnPart.replace(/^->\s*/, '').trim() : undefined;
+                const isAsync = fnKeyword.includes('async');
+                const signature = `${fnKeyword} ${name}${generics}(${paramsStr})${returnPart ? ' ' + returnPart : ''}`;
+                elements.push({
+                    kind: 'method',
+                    name,
+                    signature,
+                    parameters,
+                    returnType,
+                    docstring,
+                    filePath,
+                    lineNumber,
+                    parentClass: typeName,
+                    isAsync,
+                    isExported: true,
+                    isPublic: true,
+                    imports,
+                    packageName,
+                    sourceContext: this.getSourceContext(lines, lineNumber)
+                });
+            }
+        }
+    }
+    extractBlock(source, startIndex) {
+        let depth = 0;
+        let i = startIndex;
+        let start = -1;
+        while (i < source.length) {
+            if (source[i] === '{') {
+                if (depth === 0)
+                    start = i;
+                depth++;
+            }
+            else if (source[i] === '}') {
+                depth--;
+                if (depth === 0) {
+                    return source.slice(start + 1, i);
+                }
+            }
+            i++;
+        }
+        return null;
+    }
+    parseRustParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Skip self, &self, &mut self
+            if (/^&?(?:mut\s+)?self$/.test(trimmed))
+                continue;
+            // Format: "name: Type" or "mut name: Type"
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx > 0) {
+                let name = trimmed.slice(0, colonIdx).trim();
+                const type = trimmed.slice(colonIdx + 1).trim();
+                // Remove mut prefix from name
+                name = name.replace(/^mut\s+/, '');
+                params.push({ name, type });
+            }
+        }
+        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 line = lines[i].trim();
+            // Rust doc comments: /// or //!
+            if (line.startsWith('///') || line.startsWith('//!')) {
+                comments.unshift(line.replace(/^\/\/[/!]\s?/, ''));
+                i--;
+            }
+            else if (line.startsWith('#[')) {
+                // Skip attributes
+                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/scanner.test.d.ts

@@ -0,0 +1 @@
+export {};