skrypt-ai 0.4.2 → 0.6.0

package/dist/scanner/swift.js

@@ -0,0 +1,392 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Swift source files
+ * Extracts: public/open classes, structs, enums, protocols, actors, functions, methods
+ */
+export class SwiftScanner {
+    languages = ['swift'];
+    canHandle(filePath) {
+        return (/\.swift$/.test(filePath) &&
+            !filePath.endsWith('Tests.swift') &&
+            !filePath.endsWith('Test.swift') &&
+            !filePath.includes('/Tests/'));
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Infer module name from path
+            const packageName = this.inferModuleName(filePath);
+            // Extract import statements
+            const imports = this.extractImports(source);
+            // Find all public/open items
+            this.extractTypes(source, lines, filePath, packageName, imports, elements);
+            this.extractTopLevelFunctions(source, lines, filePath, packageName, imports, elements);
+            this.extractMethods(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'swift',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'swift',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    inferModuleName(filePath) {
+        const parts = filePath.split('/');
+        // Look for Sources/ directory (Swift Package Manager convention)
+        const sourcesIndex = parts.indexOf('Sources');
+        if (sourcesIndex >= 0 && sourcesIndex + 1 < parts.length) {
+            return parts[sourcesIndex + 1] ?? 'unknown';
+        }
+        // Fall back to parent directory
+        return parts[parts.length - 2] ?? 'unknown';
+    }
+    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;
+    }
+    extractTypes(source, lines, filePath, packageName, imports, elements) {
+        // Match: public/open class/struct/enum/protocol/actor TypeName
+        // Allow optional modifiers like "final" or "indirect" between access level and type keyword
+        const typeRegex = /^(public|open)\s+(?:(?:final|indirect)\s+)?(class|struct|enum|protocol|actor)\s+(\w+)/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const access = match[1];
+            const kind = match[2];
+            const name = match[3];
+            if (!access || !kind || !name)
+                continue;
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = `${access} ${kind} ${name}`;
+            elements.push({
+                kind: 'class',
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    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;
+    }
+    extractTrailingSignature(source, openIndex) {
+        // Find closing paren
+        let depth = 0;
+        let closeIndex = openIndex;
+        for (let i = openIndex; i < source.length; i++) {
+            if (source[i] === '(')
+                depth++;
+            else if (source[i] === ')') {
+                depth--;
+                if (depth === 0) {
+                    closeIndex = i;
+                    break;
+                }
+            }
+        }
+        // Scan after ')' for async/throws/rethrows/-> up to '{' or newline
+        const afterParen = source.slice(closeIndex + 1);
+        const trailingMatch = afterParen.match(/^([^{\n]*)/);
+        const trailing = trailingMatch?.[1] ?? '';
+        const isAsync = /\basync\b/.test(trailing);
+        const isThrows = /\bthrows\b/.test(trailing);
+        const isRethrows = /\brethrows\b/.test(trailing);
+        const returnMatch = trailing.match(/->\s*(.+?)$/);
+        const returnType = returnMatch?.[1]?.trim() || undefined;
+        return { closeIndex, isAsync, isThrows, isRethrows, returnType };
+    }
+    extractTopLevelFunctions(source, lines, filePath, packageName, imports, elements) {
+        // Match up to the opening '(' only (allow optional generic params <...>)
+        // Allow optional modifiers like static, class, final, override between access level and func
+        const funcRegex = /^(public|open)\s+(?:(?:static|class|final|override)\s+)*func\s+(\w+)\s*(?:<[^>]*>\s*)?\(/gm;
+        let match;
+        while ((match = funcRegex.exec(source)) !== null) {
+            const access = match[1];
+            const name = match[2];
+            if (!access || !name)
+                continue;
+            // Check if this is at the top level (not indented)
+            const lineNumber = this.getLineNumber(source, match.index);
+            const lineContent = lines[lineNumber - 1];
+            if (!lineContent || /^\s+/.test(lineContent))
+                continue;
+            const openParenIndex = match.index + match[0].length - 1;
+            const paramsStr = this.extractParenContent(source, openParenIndex);
+            if (paramsStr === null)
+                continue;
+            const { isAsync, isThrows, isRethrows, returnType } = this.extractTrailingSignature(source, openParenIndex);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseSwiftParams(paramsStr);
+            const signature = this.buildSignature(access, name, paramsStr, isAsync, isThrows, isRethrows, returnType);
+            elements.push({
+                kind: 'function',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                isAsync,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    extractMethods(source, lines, filePath, packageName, imports, elements) {
+        // Find type blocks (class/struct/enum/protocol/actor) and extract methods inside them
+        const typeBlockRegex = /^(?:public|open)\s+(?:(?:final|indirect)\s+)?(?:class|struct|enum|protocol|actor)\s+(\w+)[^{]*\{/gm;
+        let typeMatch;
+        while ((typeMatch = typeBlockRegex.exec(source)) !== null) {
+            const typeName = typeMatch[1];
+            if (!typeName)
+                continue;
+            const blockStart = typeMatch.index + typeMatch[0].length - 1;
+            const blockBody = this.extractBlock(source, blockStart);
+            if (!blockBody)
+                continue;
+            // Find public/open func inside the block — match up to opening '(' only (allow optional generic params)
+            // Allow optional modifiers like static, class, final, override between access level and func
+            const methodRegex = /^\s+(public|open)\s+(?:(?:static|class|final|override)\s+)*func\s+(\w+)\s*(?:<[^>]*>\s*)?\(/gm;
+            let methodMatch;
+            while ((methodMatch = methodRegex.exec(blockBody)) !== null) {
+                const access = methodMatch[1];
+                const name = methodMatch[2];
+                if (!access || !name)
+                    continue;
+                const openParenIndex = methodMatch.index + methodMatch[0].length - 1;
+                const paramsStr = this.extractParenContent(blockBody, openParenIndex);
+                if (paramsStr === null)
+                    continue;
+                const { isAsync, isThrows, isRethrows, returnType } = this.extractTrailingSignature(blockBody, openParenIndex);
+                // Calculate line number relative to the full source
+                const bodyOffset = blockStart + 1;
+                const fullIndex = bodyOffset + methodMatch.index;
+                const lineNumber = this.getLineNumber(source, fullIndex);
+                const docstring = this.getDocComment(lines, lineNumber - 1);
+                const parameters = this.parseSwiftParams(paramsStr);
+                const signature = this.buildSignature(access, name, paramsStr, isAsync, isThrows, isRethrows, returnType);
+                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)
+                });
+            }
+        }
+    }
+    buildSignature(access, name, paramsStr, isAsync, isThrows, isRethrows, returnType) {
+        let sig = `${access} func ${name}(${paramsStr})`;
+        if (isAsync)
+            sig += ' async';
+        if (isThrows)
+            sig += ' throws';
+        if (isRethrows)
+            sig += ' rethrows';
+        if (returnType)
+            sig += ` -> ${returnType}`;
+        return sig;
+    }
+    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;
+    }
+    parseSwiftParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Swift parameter formats:
+            // "externalName internalName: Type"
+            // "_ internalName: Type"
+            // "name: Type"
+            // "name: Type = defaultValue"
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx < 0)
+                continue;
+            const labelPart = trimmed.slice(0, colonIdx).trim();
+            let typePart = trimmed.slice(colonIdx + 1).trim();
+            // Check for default value
+            let defaultValue;
+            const equalsIdx = this.findDefaultValueSplit(typePart);
+            if (equalsIdx >= 0) {
+                defaultValue = typePart.slice(equalsIdx + 1).trim();
+                typePart = typePart.slice(0, equalsIdx).trim();
+            }
+            // Parse label part: could be "externalName internalName", "_ name", or just "name"
+            const labelParts = labelPart.split(/\s+/);
+            let name;
+            if (labelParts.length >= 2) {
+                // "external internal" or "_ internal"
+                name = labelParts[1] ?? labelParts[0] ?? trimmed;
+            }
+            else {
+                name = labelParts[0] ?? trimmed;
+            }
+            params.push({
+                name,
+                type: typePart || undefined,
+                default: defaultValue
+            });
+        }
+        return params;
+    }
+    findDefaultValueSplit(typePart) {
+        // Find '=' that's not inside generics < >
+        let depth = 0;
+        for (let i = 0; i < typePart.length; i++) {
+            const ch = typePart[i];
+            if (ch === '<' || ch === '(' || ch === '[')
+                depth++;
+            else if (ch === '>' || ch === ')' || ch === ']')
+                depth--;
+            else if (ch === '=' && depth === 0)
+                return i;
+        }
+        return -1;
+    }
+    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();
+            // Swift single-line doc comment: ///
+            if (line.startsWith('///')) {
+                comments.unshift(line.replace(/^\/\/\/\s?/, ''));
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        // Check for /** */ block comment (skip blank lines before declaration)
+        if (comments.length === 0 && lineIndex > 0) {
+            let checkIdx = lineIndex - 1;
+            while (checkIdx >= 0 && lines[checkIdx]?.trim() === '')
+                checkIdx--;
+            if (checkIdx >= 0 && lines[checkIdx]?.includes('*/')) {
+                let start = checkIdx;
+                while (start >= 0 && !lines[start]?.includes('/**')) {
+                    start--;
+                }
+                if (start >= 0 && lines[start]) {
+                    const block = lines.slice(start, checkIdx + 1).join('\n');
+                    const cleaned = block
+                        .replace(/\/\*\*\s?/, '')
+                        .replace(/\*\//, '')
+                        .split('\n')
+                        .map(l => l.trim().replace(/^\*\s?/, ''))
+                        .filter(Boolean)
+                        .join('\n');
+                    return cleaned || undefined;
+                }
+            }
+        }
+        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/types.d.ts

@@ -33,7 +33,7 @@ export interface APIElement {
  */
 export interface ScanResult {
     filePath: string;
-    language: 'python' | 'javascript' | 'typescript' | 'go' | 'rust';
+    language: 'python' | 'javascript' | 'typescript' | 'go' | 'rust' | 'java' | 'csharp' | 'php' | 'kotlin' | 'swift' | 'ruby';
     elements: APIElement[];
     errors: string[];
 }

package/dist/template/content/docs/_navigation.json

@@ -0,0 +1,46 @@
+{
+  "navigation": [
+    {
+      "group": "API Reference",
+      "pages": [
+        "api-reference/core",
+        "api-reference/tools",
+        "api-reference/types",
+        "api-reference/integrations",
+        "api-reference/other"
+      ]
+    }
+  ],
+  "groups": [
+    {
+      "group": "Core API",
+      "pages": [
+        "api-reference/core"
+      ]
+    },
+    {
+      "group": "Tools & Utilities",
+      "pages": [
+        "api-reference/tools"
+      ]
+    },
+    {
+      "group": "Types & Interfaces",
+      "pages": [
+        "api-reference/types"
+      ]
+    },
+    {
+      "group": "Integrations",
+      "pages": [
+        "api-reference/integrations"
+      ]
+    },
+    {
+      "group": "Other",
+      "pages": [
+        "api-reference/other"
+      ]
+    }
+  ]
+}