skrypt-ai 0.6.1 → 0.8.0

package/dist/scanner/integration.test.js

@@ -1,180 +0,0 @@
-/**
- * Integration tests for the full scanning pipeline
- */
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { writeFileSync, mkdirSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { scanDirectory, scanFile } from './index.js';
-const TEST_DIR = join(process.cwd(), 'test-fixtures');
-describe('Scanner Integration', () => {
-    beforeAll(() => {
-        // Create test fixtures
-        mkdirSync(TEST_DIR, { recursive: true });
-        // TypeScript file
-        writeFileSync(join(TEST_DIR, 'sample.ts'), `
-/**
- * Add two numbers
- * @param a First number
- * @param b Second number
- */
-export function add(a: number, b: number): number {
-  return a + b;
-}
-
-export class Calculator {
-  value: number = 0;
-
-  add(n: number): this {
-    this.value += n;
-    return this;
-  }
-}
-`);
-        // Python file
-        writeFileSync(join(TEST_DIR, 'utils.py'), `
-"""Utility functions."""
-
-def greet(name: str) -> str:
-    """Greet someone by name."""
-    return f"Hello, {name}!"
-
-class Helper:
-    """Helper class."""
-
-    def process(self, data: dict) -> dict:
-        """Process data."""
-        return data
-`);
-        // Go file
-        writeFileSync(join(TEST_DIR, 'handlers.go'), `
-package handlers
-
-// GetUser retrieves a user
-func GetUser(id string) string {
-    return id
-}
-
-type Service struct {
-    name string
-}
-`);
-        // Rust file
-        writeFileSync(join(TEST_DIR, 'lib.rs'), `
-/// Configuration struct
-pub struct Config {
-    pub name: String,
-}
-
-impl Config {
-    /// Create new config
-    pub fn new() -> Self {
-        Config { name: String::new() }
-    }
-}
-
-/// Parse config from string
-pub fn parse_config(s: &str) -> Config {
-    Config { name: s.to_string() }
-}
-`);
-    });
-    afterAll(() => {
-        // Cleanup test fixtures
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true });
-        }
-    });
-    describe('scanDirectory', () => {
-        it('scans all supported languages', async () => {
-            const result = await scanDirectory(TEST_DIR);
-            expect(result.errors).toHaveLength(0);
-            expect(result.files.length).toBeGreaterThanOrEqual(4);
-            expect(result.totalElements).toBeGreaterThanOrEqual(8);
-            // Check we found elements from each language
-            const languages = new Set(result.files.map(f => f.language));
-            expect(languages.has('typescript')).toBe(true);
-            expect(languages.has('python')).toBe(true);
-            expect(languages.has('go')).toBe(true);
-            expect(languages.has('rust')).toBe(true);
-        });
-        it('respects exclude patterns', async () => {
-            const result = await scanDirectory(TEST_DIR, {
-                exclude: ['**/utils.py']
-            });
-            // Should not find the utils.py file
-            const fileNames = result.files.map(f => f.filePath);
-            const hasPython = fileNames.some(f => f.includes('utils.py'));
-            expect(hasPython).toBe(false);
-        });
-        it('respects include patterns', async () => {
-            const result = await scanDirectory(TEST_DIR, {
-                include: ['**/*.ts']
-            });
-            expect(result.files.length).toBe(1);
-            expect(result.files[0].language).toBe('typescript');
-        });
-        it('calls progress callback', async () => {
-            const progress = [];
-            await scanDirectory(TEST_DIR, {
-                onProgress: (current, total) => {
-                    progress.push({ current, total });
-                }
-            });
-            expect(progress.length).toBeGreaterThan(0);
-            expect(progress[0].current).toBe(1);
-        });
-    });
-    describe('scanFile', () => {
-        it('scans a single TypeScript file', async () => {
-            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
-            expect(result.errors).toHaveLength(0);
-            expect(result.language).toBe('typescript');
-            expect(result.elements.length).toBeGreaterThanOrEqual(2);
-            const functionNames = result.elements.map(e => e.name);
-            expect(functionNames).toContain('add');
-            expect(functionNames).toContain('Calculator');
-        });
-        it('scans a single Python file', async () => {
-            const result = await scanFile(join(TEST_DIR, 'utils.py'));
-            expect(result.errors).toHaveLength(0);
-            expect(result.language).toBe('python');
-            const names = result.elements.map(e => e.name);
-            expect(names).toContain('greet');
-            expect(names).toContain('Helper');
-        });
-        it('returns error for unsupported file type', async () => {
-            const result = await scanFile(join(TEST_DIR, 'unknown.xyz'));
-            expect(result.errors.length).toBeGreaterThan(0);
-            expect(result.elements).toHaveLength(0);
-        });
-    });
-    describe('single file via scanDirectory', () => {
-        it('accepts a single file path', async () => {
-            const result = await scanDirectory(join(TEST_DIR, 'sample.ts'));
-            expect(result.errors).toHaveLength(0);
-            expect(result.files.length).toBe(1);
-            expect(result.files[0].language).toBe('typescript');
-        });
-    });
-    describe('element extraction', () => {
-        it('extracts function parameters', async () => {
-            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
-            const addFn = result.elements.find(e => e.name === 'add');
-            expect(addFn).toBeDefined();
-            expect(addFn?.parameters).toHaveLength(2);
-            expect(addFn?.parameters[0].name).toBe('a');
-            expect(addFn?.parameters[0].type).toBe('number');
-        });
-        it('extracts docstrings', async () => {
-            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
-            const addFn = result.elements.find(e => e.name === 'add');
-            expect(addFn?.docstring).toContain('Add two numbers');
-        });
-        it('extracts class methods', async () => {
-            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
-            const addMethod = result.elements.find(e => e.name === 'add' && e.kind === 'method');
-            expect(addMethod).toBeDefined();
-            expect(addMethod?.parentClass).toBe('Calculator');
-        });
-    });
-});

package/dist/scanner/scanner.test.js

@@ -1,210 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { scanFile, scanDirectory } from './index.js';
-import { join } from 'path';
-const TESTDATA = join(process.cwd(), 'testdata');
-describe('Scanner', () => {
-    describe('scanFile', () => {
-        describe('Python files', () => {
-            it('should scan Python file and extract elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                expect(result.errors).toHaveLength(0);
-                expect(result.language).toBe('python');
-                expect(result.elements.length).toBeGreaterThan(0);
-            });
-            it('should find expected Python functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('greet');
-                expect(names).toContain('fetch_data');
-            });
-            it('should find Python class and methods', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Calculator');
-                expect(names).toContain('add');
-                expect(names).toContain('multiply');
-            });
-            it('should exclude private Python elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const names = result.elements.map(e => e.name);
-                expect(names).not.toContain('_private_method');
-                expect(names).not.toContain('_private_function');
-                expect(names).not.toContain('_PrivateClass');
-            });
-            it('should detect async Python functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const fetchData = result.elements.find(e => e.name === 'fetch_data');
-                expect(fetchData).toBeDefined();
-                expect(fetchData?.isAsync).toBe(true);
-            });
-            it('should extract Python function parameters', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const greet = result.elements.find(e => e.name === 'greet');
-                expect(greet).toBeDefined();
-                expect(greet?.parameters).toHaveLength(2);
-                expect(greet?.parameters[0].name).toBe('name');
-                expect(greet?.parameters[0].type).toBe('str');
-            });
-            it('should extract Python docstrings', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.py'));
-                const greet = result.elements.find(e => e.name === 'greet');
-                expect(greet?.docstring).toContain('Generate a greeting');
-            });
-        });
-        describe('TypeScript files', () => {
-            it('should scan TypeScript file and extract elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                expect(result.errors).toHaveLength(0);
-                expect(result.language).toBe('typescript');
-                expect(result.elements.length).toBeGreaterThan(0);
-            });
-            it('should find expected TypeScript functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('greet');
-                expect(names).toContain('fetchData');
-                expect(names).toContain('processItems');
-            });
-            it('should find TypeScript class and methods', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Calculator');
-                expect(names).toContain('add');
-                expect(names).toContain('multiply');
-            });
-            it('should exclude non-exported TypeScript elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                const names = result.elements.map(e => e.name);
-                expect(names).not.toContain('internalHelper');
-                expect(names).not.toContain('_privateFunction');
-            });
-            it('should detect async TypeScript functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                const fetchData = result.elements.find(e => e.name === 'fetchData');
-                const processItems = result.elements.find(e => e.name === 'processItems');
-                expect(fetchData?.isAsync).toBe(true);
-                expect(processItems?.isAsync).toBe(true);
-            });
-            it('should set parentClass for methods', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.ts'));
-                const addMethod = result.elements.find(e => e.name === 'add');
-                expect(addMethod?.parentClass).toBe('Calculator');
-                expect(addMethod?.kind).toBe('method');
-            });
-        });
-        describe('Go files', () => {
-            it('should scan Go file and extract elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                expect(result.errors).toHaveLength(0);
-                expect(result.language).toBe('go');
-                expect(result.elements.length).toBeGreaterThan(0);
-            });
-            it('should find exported Go functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Greet');
-                expect(names).toContain('FetchData');
-                expect(names).toContain('NewCalculator');
-                expect(names).toContain('ProcessItems');
-            });
-            it('should find Go types', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Config');
-                expect(names).toContain('Calculator');
-                expect(names).toContain('Client');
-            });
-            it('should find Go methods', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Add');
-                expect(names).toContain('Multiply');
-            });
-            it('should exclude non-exported Go functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                const names = result.elements.map(e => e.name);
-                expect(names).not.toContain('privateFunction');
-                expect(names).not.toContain('privateMethod');
-            });
-            it('should extract Go doc comments', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.go'));
-                const greet = result.elements.find(e => e.name === 'Greet');
-                expect(greet?.docstring).toContain('generates a greeting');
-            });
-        });
-        describe('Rust files', () => {
-            it('should scan Rust file and extract elements', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                expect(result.errors).toHaveLength(0);
-                expect(result.language).toBe('rust');
-                expect(result.elements.length).toBeGreaterThan(0);
-            });
-            it('should find pub Rust functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('greet');
-                expect(names).toContain('fetch_data');
-                expect(names).toContain('process_items');
-            });
-            it('should find pub Rust types', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('Config');
-                expect(names).toContain('Calculator');
-                expect(names).toContain('Client');
-            });
-            it('should find pub impl methods', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const names = result.elements.map(e => e.name);
-                expect(names).toContain('new');
-                expect(names).toContain('add');
-                expect(names).toContain('multiply');
-            });
-            it('should exclude non-pub Rust functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const names = result.elements.map(e => e.name);
-                expect(names).not.toContain('private_function');
-                expect(names).not.toContain('private_method');
-            });
-            it('should detect async Rust functions', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const fetchData = result.elements.find(e => e.name === 'fetch_data');
-                expect(fetchData?.isAsync).toBe(true);
-            });
-            it('should extract Rust doc comments', async () => {
-                const result = await scanFile(join(TESTDATA, 'sample.rs'));
-                const greet = result.elements.find(e => e.name === 'greet');
-                expect(greet?.docstring).toContain('Generate a greeting');
-            });
-        });
-    });
-    describe('scanDirectory', () => {
-        it('should scan multiple files in directory', async () => {
-            const result = await scanDirectory(TESTDATA, {
-                include: ['**/*.py', '**/*.ts', '**/*.go', '**/*.rs'],
-                exclude: [],
-            });
-            expect(result.files.length).toBeGreaterThanOrEqual(4);
-            expect(result.totalElements).toBeGreaterThan(0);
-            expect(result.errors).toHaveLength(0);
-        });
-        it('should respect include patterns', async () => {
-            const result = await scanDirectory(TESTDATA, {
-                include: ['**/*.py'],
-                exclude: [],
-            });
-            expect(result.files.every(f => f.language === 'python')).toBe(true);
-        });
-        it('should have files from all languages', async () => {
-            const result = await scanDirectory(TESTDATA, {
-                include: ['**/*.py', '**/*.ts', '**/*.go', '**/*.rs'],
-                exclude: [],
-            });
-            const languages = new Set(result.files.map(f => f.language));
-            expect(languages.has('python')).toBe(true);
-            expect(languages.has('typescript')).toBe(true);
-            expect(languages.has('go')).toBe(true);
-            expect(languages.has('rust')).toBe(true);
-        });
-    });
-});

package/dist/scanner/typescript.manual-test.d.ts

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

package/dist/scanner/typescript.manual-test.js

@@ -1,112 +0,0 @@
-import { scanFile, scanDirectory } from './index.js';
-async function runTests() {
-    console.log('=== TypeScript Scanner Tests ===\n');
-    // Test 1: Scan single TypeScript file
-    console.log('Test 1: Scan single TypeScript file');
-    const result = await scanFile('testdata/sample.ts');
-    if (result.errors.length > 0) {
-        console.log('  ✗ errors:', result.errors);
-        process.exit(1);
-    }
-    console.log(`  found ${result.elements.length} elements`);
-    console.log(`  language: ${result.language}`);
-    // Check we found expected elements
-    const names = result.elements.map(e => e.name);
-    const expected = ['greet', 'fetchData', 'processItems', 'Calculator', 'constructor', 'add', 'multiply'];
-    for (const name of expected) {
-        if (!names.includes(name)) {
-            console.log(`  ✗ missing expected element: ${name}`);
-            console.log('  found:', names);
-            process.exit(1);
-        }
-    }
-    // Check private/non-exported elements are excluded
-    const excluded = ['_privateMethod', '_privateFunction', 'internalHelper'];
-    for (const name of excluded) {
-        if (names.includes(name)) {
-            console.log(`  ✗ should have excluded: ${name}`);
-            process.exit(1);
-        }
-    }
-    console.log('  ✓ found all expected elements');
-    console.log('  ✓ excluded private/non-exported elements\n');
-    // Test 2: Check function details
-    console.log('Test 2: Check function details');
-    const greet = result.elements.find(e => e.name === 'greet');
-    if (greet.kind !== 'function') {
-        console.log(`  ✗ greet.kind should be 'function', got '${greet.kind}'`);
-        process.exit(1);
-    }
-    if (greet.parameters.length !== 2) {
-        console.log(`  ✗ greet should have 2 params, got ${greet.parameters.length}`);
-        process.exit(1);
-    }
-    if (greet.returnType !== 'string') {
-        console.log(`  ✗ greet.returnType should be 'string', got '${greet.returnType}'`);
-        process.exit(1);
-    }
-    console.log('  ✓ function details correct\n');
-    // Test 3: Check async function
-    console.log('Test 3: Check async function');
-    const fetchData = result.elements.find(e => e.name === 'fetchData');
-    if (!fetchData.isAsync) {
-        console.log('  ✗ fetchData should be async');
-        process.exit(1);
-    }
-    console.log('  ✓ async detected correctly\n');
-    // Test 4: Check arrow function
-    console.log('Test 4: Check arrow function');
-    const processItems = result.elements.find(e => e.name === 'processItems');
-    if (processItems.kind !== 'function') {
-        console.log(`  ✗ processItems.kind should be 'function', got '${processItems.kind}'`);
-        process.exit(1);
-    }
-    if (!processItems.isAsync) {
-        console.log('  ✗ processItems should be async');
-        process.exit(1);
-    }
-    console.log('  ✓ arrow function detected correctly\n');
-    // Test 5: Check class and methods
-    console.log('Test 5: Check class and methods');
-    const calculator = result.elements.find(e => e.name === 'Calculator');
-    const addMethod = result.elements.find(e => e.name === 'add');
-    if (calculator.kind !== 'class') {
-        console.log(`  ✗ Calculator.kind should be 'class', got '${calculator.kind}'`);
-        process.exit(1);
-    }
-    if (addMethod.kind !== 'method') {
-        console.log(`  ✗ add.kind should be 'method', got '${addMethod.kind}'`);
-        process.exit(1);
-    }
-    if (addMethod.parentClass !== 'Calculator') {
-        console.log(`  ✗ add.parentClass should be 'Calculator', got '${addMethod.parentClass}'`);
-        process.exit(1);
-    }
-    console.log('  ✓ class and methods correct\n');
-    // Test 6: Scan directory with both Python and TypeScript
-    console.log('Test 6: Scan directory with multiple languages');
-    const dirResult = await scanDirectory('testdata', {
-        include: ['**/*.py', '**/*.ts'],
-        exclude: []
-    });
-    console.log(`  scanned ${dirResult.files.length} files`);
-    console.log(`  found ${dirResult.totalElements} total elements`);
-    const languages = new Set(dirResult.files.map(f => f.language));
-    if (!languages.has('python') || !languages.has('typescript')) {
-        console.log('  ✗ should have found both Python and TypeScript');
-        console.log('  languages:', [...languages]);
-        process.exit(1);
-    }
-    console.log('  ✓ multi-language scan works\n');
-    // Print summary of all elements
-    console.log('=== Elements Found ===');
-    for (const el of result.elements) {
-        const prefix = el.parentClass ? `${el.parentClass}.` : '';
-        console.log(`  [${el.kind}] ${prefix}${el.name}`);
-    }
-    console.log('\n✓ All TypeScript scanner tests passed');
-}
-runTests().catch(err => {
-    console.error('Test failed:', err);
-    process.exit(1);
-});