skrypt-ai 0.1.0

package/dist/scanner/content-type.test.js

@@ -0,0 +1,231 @@
+import { describe, it, expect } from 'vitest';
+import { classifyElement, classifyElements, getRecommendedStructure, getPromptForContentType } from './content-type.js';
+function createMockElement(overrides = {}) {
+    return {
+        kind: 'function',
+        name: 'testFunction',
+        signature: 'function testFunction()',
+        parameters: [],
+        filePath: '/src/test.ts',
+        lineNumber: 1,
+        isExported: true,
+        isPublic: true,
+        ...overrides,
+    };
+}
+describe('Content Type Detection', () => {
+    describe('classifyElement', () => {
+        it('should classify API elements with multiple parameters', () => {
+            const element = createMockElement({
+                name: 'fetchData',
+                parameters: [
+                    { name: 'url', type: 'string' },
+                    { name: 'options', type: 'RequestOptions' },
+                    { name: 'timeout', type: 'number' },
+                ],
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('api');
+            expect(result.confidence).toBeGreaterThan(0);
+        });
+        it('should classify handler/endpoint patterns as API', () => {
+            const element = createMockElement({
+                name: 'userHandler',
+                kind: 'method',
+                parentClass: 'UserController',
+                filePath: '/src/handlers/user.ts',
+                parameters: [
+                    { name: 'req', type: 'Request' },
+                    { name: 'res', type: 'Response' },
+                ],
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('api');
+        });
+        it('should classify HTTP methods as API', () => {
+            const element = createMockElement({
+                signature: 'async function handleGET(request: Request): Promise<Response>',
+                docstring: 'Handles GET requests for user data',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('api');
+        });
+        it('should classify config/setup functions as guide', () => {
+            const element = createMockElement({
+                name: 'configureDatabase',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('guide');
+        });
+        it('should classify init functions as guide', () => {
+            const element = createMockElement({
+                name: 'initializeApp',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('guide');
+        });
+        it('should classify example files as tutorial', () => {
+            const element = createMockElement({
+                name: 'main',
+                filePath: '/examples/quickstart.ts',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('tutorial');
+        });
+        it('should classify demo functions as tutorial', () => {
+            const element = createMockElement({
+                name: 'demoFeature',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('tutorial');
+        });
+        it('should classify simple functions with few params as tutorial', () => {
+            const element = createMockElement({
+                name: 'simpleFunction',
+                kind: 'function',
+                parameters: [{ name: 'input', type: 'string' }],
+            });
+            const result = classifyElement(element);
+            // Simple functions default to tutorial
+            expect(result.type).toBe('tutorial');
+        });
+        it('should classify async API patterns correctly', () => {
+            const element = createMockElement({
+                signature: 'async function createUser(data: UserData): Promise<User>',
+                parameters: [
+                    { name: 'data', type: 'UserData' },
+                    { name: 'options', type: 'CreateOptions' },
+                    { name: 'validate', type: 'boolean' },
+                ],
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('api');
+        });
+        it('should return tutorial for simple functions with no indicators', () => {
+            // Simple functions with few params default to tutorial
+            const element = createMockElement({
+                name: 'x',
+                kind: 'function',
+                parameters: [],
+                docstring: undefined,
+                filePath: '/src/utils.ts',
+            });
+            const result = classifyElement(element);
+            // Gets tutorial because simple function with <=1 params
+            expect(result.type).toBe('tutorial');
+        });
+        it('should return overview for class elements with no indicators', () => {
+            // Classes without other indicators get overview
+            const element = createMockElement({
+                name: 'X',
+                kind: 'class',
+                parameters: [],
+                docstring: undefined,
+                filePath: '/src/utils.ts',
+            });
+            const result = classifyElement(element);
+            expect(result.type).toBe('overview');
+        });
+        it('should include reasons for classification', () => {
+            const element = createMockElement({
+                name: 'handler',
+                filePath: '/src/handlers/api.ts',
+            });
+            const result = classifyElement(element);
+            expect(result.reasons.length).toBeGreaterThan(0);
+        });
+    });
+    describe('classifyElements', () => {
+        it('should group elements by content type', () => {
+            const elements = [
+                createMockElement({
+                    name: 'fetchUsers',
+                    kind: 'method',
+                    parentClass: 'UserService',
+                    parameters: [
+                        { name: 'page', type: 'number' },
+                        { name: 'limit', type: 'number' },
+                        { name: 'filter', type: 'Filter' },
+                    ],
+                }),
+                createMockElement({
+                    name: 'configureAuth',
+                    kind: 'function',
+                    parameters: [
+                        { name: 'options', type: 'AuthOptions' },
+                        { name: 'provider', type: 'Provider' },
+                    ],
+                }),
+                createMockElement({
+                    name: 'exampleUsage',
+                    filePath: '/examples/demo.ts',
+                }),
+            ];
+            const result = classifyElements(elements);
+            expect(result.get('api')?.length).toBeGreaterThanOrEqual(1);
+            // configureAuth should be guide (config pattern)
+            expect(result.get('guide')?.length).toBeGreaterThanOrEqual(1);
+            expect(result.get('tutorial')?.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should handle empty elements array', () => {
+            const result = classifyElements([]);
+            expect(result.get('api')).toHaveLength(0);
+            expect(result.get('guide')).toHaveLength(0);
+            expect(result.get('tutorial')).toHaveLength(0);
+            expect(result.get('overview')).toHaveLength(0);
+        });
+    });
+    describe('getRecommendedStructure', () => {
+        it('should return sections grouped by type', () => {
+            const elements = [
+                createMockElement({
+                    name: 'createUser',
+                    parameters: [
+                        { name: 'data', type: 'UserData' },
+                        { name: 'options', type: 'Options' },
+                        { name: 'callback', type: 'Function' },
+                    ],
+                }),
+                createMockElement({
+                    name: 'setupDatabase',
+                }),
+            ];
+            const result = getRecommendedStructure(elements);
+            expect(result.sections.length).toBeGreaterThan(0);
+            expect(result.stats.api + result.stats.guide + result.stats.tutorial + result.stats.overview).toBe(elements.length);
+        });
+        it('should provide stats for each type', () => {
+            const elements = [
+                createMockElement({ name: 'api1', parameters: [{ name: 'a' }, { name: 'b' }, { name: 'c' }] }),
+                createMockElement({ name: 'api2', parameters: [{ name: 'x' }, { name: 'y' }, { name: 'z' }] }),
+                createMockElement({ name: 'config1' }),
+            ];
+            const result = getRecommendedStructure(elements);
+            expect(typeof result.stats.api).toBe('number');
+            expect(typeof result.stats.guide).toBe('number');
+            expect(typeof result.stats.tutorial).toBe('number');
+            expect(typeof result.stats.overview).toBe('number');
+        });
+    });
+    describe('getPromptForContentType', () => {
+        it('should return appropriate prompt for api type', () => {
+            const prompt = getPromptForContentType('api');
+            expect(prompt).toContain('API reference');
+            expect(prompt).toContain('parameter');
+        });
+        it('should return appropriate prompt for guide type', () => {
+            const prompt = getPromptForContentType('guide');
+            expect(prompt).toContain('guide');
+            expect(prompt).toContain('setup');
+        });
+        it('should return appropriate prompt for tutorial type', () => {
+            const prompt = getPromptForContentType('tutorial');
+            expect(prompt).toContain('tutorial');
+            expect(prompt).toContain('beginner');
+        });
+        it('should return appropriate prompt for overview type', () => {
+            const prompt = getPromptForContentType('overview');
+            expect(prompt).toContain('overview');
+        });
+    });
+});

package/dist/scanner/go.d.ts

@@ -0,0 +1,20 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for Go source files
+ * Extracts: functions, methods, types (structs), interfaces
+ */
+export declare class GoScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractImports;
+    private extractFunctions;
+    private extractMethods;
+    private extractTypes;
+    private parseGoParams;
+    private splitParams;
+    private parseReturnType;
+    private getLineNumber;
+    private getDocComment;
+    private getSourceContext;
+}

package/dist/scanner/go.js

@@ -0,0 +1,269 @@
+import { readFileSync } from 'fs';
+/**
+ * Scanner for Go source files
+ * Extracts: functions, methods, types (structs), interfaces
+ */
+export class GoScanner {
+    languages = ['go'];
+    canHandle(filePath) {
+        return /\.go$/.test(filePath) && !filePath.includes('_test.go');
+    }
+    async scanFile(filePath) {
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const elements = [];
+            const errors = [];
+            const lines = source.split('\n');
+            // Extract package name
+            const packageMatch = source.match(/^package\s+(\w+)/m);
+            const packageName = packageMatch?.[1] ?? 'unknown';
+            // Extract imports for context
+            const imports = this.extractImports(source);
+            // Find all exported functions, methods, types
+            this.extractFunctions(source, lines, filePath, packageName, imports, elements);
+            this.extractMethods(source, lines, filePath, packageName, imports, elements);
+            this.extractTypes(source, lines, filePath, packageName, imports, elements);
+            return {
+                filePath,
+                language: 'go',
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language: 'go',
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    extractImports(source) {
+        const imports = [];
+        // Single import
+        const singleMatch = source.matchAll(/^import\s+"([^"]+)"/gm);
+        for (const m of singleMatch) {
+            if (m[1])
+                imports.push(m[1]);
+        }
+        // Import block
+        const blockMatch = source.match(/import\s*\(([\s\S]*?)\)/m);
+        if (blockMatch?.[1]) {
+            const importLines = blockMatch[1].split('\n');
+            for (const line of importLines) {
+                const match = line.match(/"([^"]+)"/);
+                if (match?.[1])
+                    imports.push(match[1]);
+            }
+        }
+        return imports;
+    }
+    extractFunctions(source, lines, filePath, packageName, imports, elements) {
+        // Match: func FunctionName(params) returnType
+        // Only exported (uppercase first letter)
+        const funcRegex = /^func\s+([A-Z][a-zA-Z0-9_]*)\s*(\[[^\]]+\])?\s*\(([^)]*)\)\s*([^{]*)/gm;
+        let match;
+        while ((match = funcRegex.exec(source)) !== null) {
+            const name = match[1];
+            const paramsStr = match[3];
+            if (!name || paramsStr === undefined)
+                continue;
+            const typeParams = match[2] ?? '';
+            const returnPart = (match[4] ?? '').trim();
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseGoParams(paramsStr);
+            const returnType = this.parseReturnType(returnPart);
+            const signature = `func ${name}${typeParams}(${paramsStr})${returnPart ? ' ' + returnPart : ''}`;
+            elements.push({
+                kind: 'function',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    extractMethods(source, lines, filePath, packageName, imports, elements) {
+        // Match: func (receiver Type) MethodName(params) returnType
+        const methodRegex = /^func\s+\((\w+)\s+\*?(\w+)\)\s+([A-Z][a-zA-Z0-9_]*)\s*(\[[^\]]+\])?\s*\(([^)]*)\)\s*([^{]*)/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const receiverVar = match[1];
+            const receiverType = match[2];
+            const name = match[3];
+            const paramsStr = match[5];
+            if (!receiverVar || !receiverType || !name || paramsStr === undefined)
+                continue;
+            const typeParams = match[4] ?? '';
+            const returnPart = (match[6] ?? '').trim();
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const parameters = this.parseGoParams(paramsStr);
+            const returnType = this.parseReturnType(returnPart);
+            const receiverFull = match[0].match(/\([^)]+\)/)?.[0] ?? `(${receiverVar} ${receiverType})`;
+            const signature = `func ${receiverFull} ${name}${typeParams}(${paramsStr})${returnPart ? ' ' + returnPart : ''}`;
+            elements.push({
+                kind: 'method',
+                name,
+                signature,
+                parameters,
+                returnType,
+                docstring,
+                filePath,
+                lineNumber,
+                parentClass: receiverType,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber)
+            });
+        }
+    }
+    extractTypes(source, lines, filePath, packageName, imports, elements) {
+        // Match: type TypeName struct/interface
+        const typeRegex = /^type\s+([A-Z][a-zA-Z0-9_]*)\s+(?:struct|interface)\s*\{/gm;
+        let match;
+        while ((match = typeRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (!name)
+                continue;
+            const isInterface = match[0].includes('interface');
+            const lineNumber = this.getLineNumber(source, match.index);
+            const docstring = this.getDocComment(lines, lineNumber - 1);
+            const signature = `type ${name} ${isInterface ? 'interface' : 'struct'}`;
+            elements.push({
+                kind: 'class', // Using 'class' for Go types
+                name,
+                signature,
+                parameters: [],
+                docstring,
+                filePath,
+                lineNumber,
+                isExported: true,
+                isPublic: true,
+                imports,
+                packageName,
+                sourceContext: this.getSourceContext(lines, lineNumber, 15)
+            });
+        }
+    }
+    parseGoParams(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        // Split by comma but respect parentheses
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            // Format: "name type" or "name, name2 type" or just "type"
+            const lastSpace = trimmed.lastIndexOf(' ');
+            if (lastSpace > 0) {
+                const type = trimmed.slice(lastSpace + 1);
+                const names = trimmed.slice(0, lastSpace).split(',').map(n => n.trim());
+                for (const name of names) {
+                    if (name)
+                        params.push({ name, type });
+                }
+            }
+            else {
+                // Just a type (rare in Go)
+                params.push({ name: trimmed, type: undefined });
+            }
+        }
+        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;
+    }
+    parseReturnType(returnPart) {
+        const trimmed = returnPart.trim();
+        if (!trimmed)
+            return undefined;
+        // Remove leading/trailing braces or parens
+        if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+            return trimmed;
+        }
+        return trimmed || undefined;
+    }
+    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('//')) {
+                comments.unshift(line.replace(/^\/\/\s?/, ''));
+                i--;
+            }
+            else if (line === '') {
+                i--;
+            }
+            else {
+                break;
+            }
+        }
+        // Also check for /* */ style
+        if (comments.length === 0 && lineIndex > 0) {
+            const prevLine = lines[lineIndex - 1];
+            if (prevLine?.includes('*/')) {
+                // Find start of block comment
+                let start = lineIndex - 1;
+                while (start >= 0 && !lines[start]?.includes('/*')) {
+                    start--;
+                }
+                if (start >= 0 && lines[start]) {
+                    const block = lines.slice(start, lineIndex).join('\n');
+                    const cleaned = block
+                        .replace(/\/\*\*?/, '')
+                        .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/index.d.ts

@@ -0,0 +1,21 @@
+import { ScanResult } from './types.js';
+export * from './types.js';
+export * from './content-type.js';
+export interface ScanOptions {
+    include?: string[];
+    exclude?: string[];
+    onProgress?: (current: number, total: number, file: string) => void;
+}
+export interface ScanAllResult {
+    files: ScanResult[];
+    totalElements: number;
+    errors: string[];
+}
+/**
+ * Scan a directory for all API elements
+ */
+export declare function scanDirectory(dir: string, options?: ScanOptions): Promise<ScanAllResult>;
+/**
+ * Scan a single file
+ */
+export declare function scanFile(filePath: string): Promise<ScanResult>;

package/dist/scanner/index.js

@@ -0,0 +1,137 @@
+import { readdir } from 'fs/promises';
+import { join, extname } from 'path';
+import { PythonScanner } from './python.js';
+import { TypeScriptScanner } from './typescript.js';
+import { GoScanner } from './go.js';
+import { RustScanner } from './rust.js';
+export * from './types.js';
+export * from './content-type.js';
+// All available scanners
+const SCANNERS = [
+    new PythonScanner(),
+    new TypeScriptScanner(),
+    new GoScanner(),
+    new RustScanner(),
+];
+/**
+ * Get the appropriate scanner for a file
+ */
+function getScannerForFile(filePath) {
+    for (const scanner of SCANNERS) {
+        if (scanner.canHandle(filePath)) {
+            return scanner;
+        }
+    }
+    return null;
+}
+/**
+ * Check if a path should be excluded based on patterns
+ */
+function shouldExclude(filePath, excludePatterns) {
+    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, ''))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a file matches include patterns
+ */
+function shouldInclude(filePath, includePatterns) {
+    if (includePatterns.length === 0)
+        return true;
+    const ext = extname(filePath);
+    for (const pattern of includePatterns) {
+        // Match extension patterns like **/*.py
+        if (pattern.includes('*')) {
+            const extPattern = pattern.split('*').pop() || '';
+            if (ext === extPattern)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Recursively find all files in a directory
+ */
+async function findFiles(dir, include, exclude) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (shouldExclude(fullPath, exclude)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (shouldInclude(fullPath, include) && getScannerForFile(fullPath)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+/**
+ * Scan a directory 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 files = await findFiles(dir, include, exclude);
+    const results = [];
+    const allErrors = [];
+    let totalElements = 0;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        options.onProgress?.(i + 1, files.length, file);
+        const scanner = getScannerForFile(file);
+        if (!scanner)
+            continue;
+        try {
+            const result = await scanner.scanFile(file);
+            results.push(result);
+            totalElements += result.elements.length;
+            allErrors.push(...result.errors);
+        }
+        catch (err) {
+            allErrors.push(`Error scanning ${file}: ${err}`);
+        }
+    }
+    return {
+        files: results,
+        totalElements,
+        errors: allErrors
+    };
+}
+/**
+ * Scan a single file
+ */
+export async function scanFile(filePath) {
+    const scanner = getScannerForFile(filePath);
+    if (!scanner) {
+        return {
+            filePath,
+            language: 'python', // default
+            elements: [],
+            errors: [`No scanner available for ${filePath}`]
+        };
+    }
+    return scanner.scanFile(filePath);
+}

package/dist/scanner/python.d.ts

@@ -0,0 +1,6 @@
+import { Scanner, ScanResult } from './types.js';
+export declare class PythonScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+}