skrypt-ai 0.7.0 → 0.8.0

package/dist/llm/llm.manual-test.js

@@ -1,112 +0,0 @@
-import { createLLMClient, generateDocumentation, fixCodeSample } from './index.js';
-import { PROVIDER_ENV_KEYS } from '../config/types.js';
-async function runTests() {
-    console.log('=== LLM Client Tests ===\n');
-    // Find an available provider
-    const providers = ['deepseek', 'openai', 'anthropic', 'google', 'openrouter', 'ollama'];
-    let availableProvider = null;
-    let availableModel = null;
-    for (const provider of providers) {
-        const envKey = PROVIDER_ENV_KEYS[provider];
-        if (!envKey || process.env[envKey]) {
-            availableProvider = provider;
-            availableModel = getTestModel(provider);
-            break;
-        }
-    }
-    if (!availableProvider) {
-        console.log('No LLM provider available. Set one of these env vars:');
-        console.log('  DEEPSEEK_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY,');
-        console.log('  GOOGLE_API_KEY, OPENROUTER_API_KEY, or run Ollama locally');
-        process.exit(0);
-    }
-    console.log(`Using provider: ${availableProvider} (${availableModel})`);
-    console.log('');
-    // Test 1: Create client
-    console.log('Test 1: Create LLM client');
-    const client = createLLMClient({
-        provider: availableProvider,
-        model: availableModel
-    });
-    console.log(`  provider: ${client.provider}`);
-    console.log('  ✓ client created\n');
-    // Test 2: Simple completion
-    console.log('Test 2: Simple completion');
-    try {
-        const response = await client.complete({
-            messages: [
-                { role: 'user', content: 'Say "hello" and nothing else.' }
-            ],
-            maxTokens: 10
-        });
-        console.log(`  response: "${response.content.trim()}"`);
-        console.log(`  model: ${response.model}`);
-        console.log(`  tokens: ${response.usage.totalTokens}`);
-        console.log('  ✓ completion works\n');
-    }
-    catch (err) {
-        console.log(`  ✗ completion failed: ${err}`);
-        process.exit(1);
-    }
-    // Test 3: Generate documentation
-    console.log('Test 3: Generate documentation');
-    try {
-        const result = await generateDocumentation(client, {
-            kind: 'function',
-            name: 'add',
-            signature: 'def add(a: int, b: int) -> int',
-            parameters: [
-                { name: 'a', type: 'int' },
-                { name: 'b', type: 'int' }
-            ],
-            returnType: 'int',
-            docstring: 'Add two numbers together.'
-        });
-        console.log(`  markdown length: ${result.markdown.length} chars`);
-        console.log(`  code example length: ${result.codeExample.length} chars`);
-        if (result.codeExample.includes('add(')) {
-            console.log('  ✓ code example calls the function\n');
-        }
-        else {
-            console.log(`  code example:\n${result.codeExample}`);
-            console.log('  ⚠ code example might not call the function\n');
-        }
-    }
-    catch (err) {
-        console.log(`  ✗ doc generation failed: ${err}`);
-        process.exit(1);
-    }
-    // Test 4: Fix broken code
-    console.log('Test 4: Fix broken code');
-    try {
-        const fixed = await fixCodeSample(client, 'print(add(1, 2)', // Missing closing paren
-        'SyntaxError: unexpected EOF while parsing', 'This is a code example for the add function');
-        console.log(`  fixed code: ${fixed}`);
-        if (fixed.includes(')')) {
-            console.log('  ✓ code was fixed\n');
-        }
-        else {
-            console.log('  ⚠ fix might be incomplete\n');
-        }
-    }
-    catch (err) {
-        console.log(`  ✗ code fix failed: ${err}`);
-        process.exit(1);
-    }
-    console.log('✓ All LLM client tests passed');
-}
-function getTestModel(provider) {
-    switch (provider) {
-        case 'deepseek': return 'deepseek-chat';
-        case 'openai': return 'gpt-4o-mini';
-        case 'anthropic': return 'claude-sonnet-4-5-20241022';
-        case 'google': return 'gemini-2.0-flash';
-        case 'ollama': return 'llama3.2:1b'; // Small model for testing
-        case 'openrouter': return 'openai/gpt-4o-mini';
-        default: return 'gpt-4o-mini';
-    }
-}
-runTests().catch(err => {
-    console.error('Test failed:', err);
-    process.exit(1);
-});

package/dist/llm/llm.mock-test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Mock tests for LLM client - tests structure without API calls
- */
-export {};

package/dist/llm/llm.mock-test.js

@@ -1,79 +0,0 @@
-/**
- * Mock tests for LLM client - tests structure without API calls
- */
-import { createLLMClient, PROVIDER_BASE_URLS } from './index.js';
-function runMockTests() {
-    console.log('=== LLM Client Mock Tests ===\n');
-    // Test 1: Client creation for each provider
-    console.log('Test 1: Create client for each provider');
-    const providers = ['deepseek', 'openai', 'anthropic', 'google', 'ollama', 'openrouter'];
-    for (const provider of providers) {
-        try {
-            // Create client to verify no errors thrown
-            createLLMClient({
-                provider,
-                model: 'test-model'
-            });
-            console.log(`  ✓ ${provider}: client created`);
-        }
-        catch (err) {
-            console.log(`  ✗ ${provider}: ${err}`);
-            process.exit(1);
-        }
-    }
-    console.log('');
-    // Test 2: Verify base URLs
-    console.log('Test 2: Verify provider base URLs');
-    const expectedUrls = {
-        deepseek: 'https://api.deepseek.com/v1',
-        openai: 'https://api.openai.com/v1',
-        anthropic: 'https://api.anthropic.com',
-        google: 'https://generativelanguage.googleapis.com/v1beta/openai',
-        ollama: 'http://localhost:11434/v1',
-        openrouter: 'https://openrouter.ai/api/v1'
-    };
-    for (const [provider, expectedUrl] of Object.entries(expectedUrls)) {
-        const actualUrl = PROVIDER_BASE_URLS[provider];
-        if (actualUrl === expectedUrl) {
-            console.log(`  ✓ ${provider}: ${actualUrl}`);
-        }
-        else {
-            console.log(`  ✗ ${provider}: expected ${expectedUrl}, got ${actualUrl}`);
-            process.exit(1);
-        }
-    }
-    console.log('');
-    // Test 3: Anthropic vs OpenAI-compatible client selection
-    console.log('Test 3: Client type selection');
-    const anthropicClient = createLLMClient({ provider: 'anthropic', model: 'claude-3' });
-    const openaiClient = createLLMClient({ provider: 'openai', model: 'gpt-4' });
-    const deepseekClient = createLLMClient({ provider: 'deepseek', model: 'deepseek-v3' });
-    // Check they're different implementations for anthropic vs others
-    const anthropicType = anthropicClient.constructor.name;
-    const openaiType = openaiClient.constructor.name;
-    const deepseekType = deepseekClient.constructor.name;
-    console.log(`  anthropic client: ${anthropicType}`);
-    console.log(`  openai client: ${openaiType}`);
-    console.log(`  deepseek client: ${deepseekType}`);
-    if (anthropicType !== openaiType) {
-        console.log('  ✓ anthropic uses different client than openai');
-    }
-    else {
-        console.log('  ✗ anthropic should use different client');
-        process.exit(1);
-    }
-    if (openaiType === deepseekType) {
-        console.log('  ✓ deepseek uses same client as openai (OpenAI-compatible)');
-    }
-    else {
-        console.log('  ✗ deepseek should use same client as openai');
-        process.exit(1);
-    }
-    console.log('');
-    console.log('✓ All mock tests passed\n');
-    console.log('To run real API tests, set an API key and run:');
-    console.log('  DEEPSEEK_API_KEY=your-key npx tsx src/llm/llm.test.ts');
-    console.log('  ANTHROPIC_API_KEY=your-key npx tsx src/llm/llm.test.ts');
-    console.log('  Or start Ollama locally');
-}
-runMockTests();

package/dist/plugins/index.d.ts

@@ -1,47 +0,0 @@
-export interface SkryptPlugin {
-    name: string;
-    version?: string;
-    onInit?: (context: PluginContext) => Promise<void> | void;
-    onBeforeScan?: (context: PluginContext) => Promise<void> | void;
-    onAfterScan?: (context: PluginContext, elements: unknown[]) => Promise<unknown[]> | unknown[];
-    onBeforeGenerate?: (context: PluginContext, elements: unknown[]) => Promise<unknown[]> | unknown[];
-    onAfterGenerate?: (context: PluginContext, docs: unknown[]) => Promise<unknown[]> | unknown[];
-    onBeforeWrite?: (context: PluginContext, docs: unknown[]) => Promise<unknown[]> | unknown[];
-    onAfterWrite?: (context: PluginContext) => Promise<void> | void;
-    transformContent?: (content: string, filePath: string) => Promise<string> | string;
-    transformElement?: (element: unknown) => Promise<unknown> | unknown;
-}
-export interface PluginContext {
-    sourcePath: string;
-    outputPath: string;
-    config: Record<string, unknown>;
-    logger: {
-        info: (msg: string) => void;
-        warn: (msg: string) => void;
-        error: (msg: string) => void;
-    };
-}
-export declare class PluginManager {
-    private plugins;
-    private context;
-    constructor(sourcePath: string, outputPath: string, config?: Record<string, unknown>);
-    loadPlugins(configPath?: string): Promise<void>;
-    private findConfigFile;
-    private loadPluginByName;
-    register(plugin: SkryptPlugin): void;
-    runHook<T>(hook: keyof SkryptPlugin, ...args: unknown[]): Promise<T | undefined>;
-    onInit(): Promise<void>;
-    onBeforeScan(): Promise<void>;
-    onAfterScan<T>(elements: T[]): Promise<T[]>;
-    onBeforeGenerate<T>(elements: T[]): Promise<T[]>;
-    onAfterGenerate<T>(docs: T[]): Promise<T[]>;
-    onBeforeWrite<T>(docs: T[]): Promise<T[]>;
-    onAfterWrite(): Promise<void>;
-    transformContent(content: string, filePath: string): Promise<string>;
-}
-export declare const builtinPlugins: {
-    timestamp: SkryptPlugin;
-    editOnGithub: (repoUrl: string, branch?: string) => SkryptPlugin;
-    toc: SkryptPlugin;
-};
-export declare function definePlugin(plugin: SkryptPlugin): SkryptPlugin;

package/dist/plugins/index.js

@@ -1,181 +0,0 @@
-// TODO: Plugin system is defined but not yet wired into the generate pipeline
-import { existsSync } from 'fs';
-import { resolve } from 'path';
-import { pathToFileURL } from 'url';
-export class PluginManager {
-    plugins = [];
-    context;
-    constructor(sourcePath, outputPath, config = {}) {
-        this.context = {
-            sourcePath,
-            outputPath,
-            config,
-            logger: {
-                info: (msg) => console.log(`[plugin] ${msg}`),
-                warn: (msg) => console.warn(`[plugin] ${msg}`),
-                error: (msg) => console.error(`[plugin] ${msg}`),
-            },
-        };
-    }
-    async loadPlugins(configPath) {
-        // Load from skrypt.config.js or skrypt.config.ts
-        const configFile = configPath || this.findConfigFile();
-        if (!configFile)
-            return;
-        try {
-            console.log(`  Loading config: ${configFile}`);
-            console.warn('  ⚠ Plugin configs execute code — only load trusted files');
-            const configUrl = pathToFileURL(configFile).href;
-            const module = await import(configUrl);
-            const config = module.default || module;
-            if (config.plugins && Array.isArray(config.plugins)) {
-                for (const plugin of config.plugins) {
-                    if (typeof plugin === 'string') {
-                        // Load plugin by name
-                        await this.loadPluginByName(plugin);
-                    }
-                    else if (typeof plugin === 'object' && plugin.name) {
-                        // Plugin object
-                        this.register(plugin);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            console.error(`Failed to load config: ${err}`);
-        }
-    }
-    findConfigFile() {
-        const candidates = [
-            'skrypt.config.js',
-            'skrypt.config.mjs',
-            'skrypt.config.ts',
-        ];
-        for (const name of candidates) {
-            const path = resolve(process.cwd(), name);
-            if (existsSync(path))
-                return path;
-        }
-        return null;
-    }
-    async loadPluginByName(name) {
-        // Validate plugin name — must be a valid npm package name, no path traversal
-        if (!/^(@[a-zA-Z0-9._-]+\/)?[a-zA-Z0-9._-]+$/.test(name)) {
-            console.warn(`Skipping plugin with invalid name: ${name}`);
-            return;
-        }
-        // Try to load from node_modules
-        try {
-            const module = await import(name);
-            const plugin = module.default || module;
-            if (plugin.name) {
-                this.register(plugin);
-            }
-        }
-        catch {
-            console.warn(`Failed to load plugin: ${name}`);
-        }
-    }
-    register(plugin) {
-        this.plugins.push(plugin);
-        console.log(`Loaded plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ''}`);
-    }
-    async runHook(hook, ...args) {
-        let result = args[0];
-        for (const plugin of this.plugins) {
-            const fn = plugin[hook];
-            if (typeof fn === 'function') {
-                try {
-                    const hookResult = await fn.call(plugin, this.context, ...args);
-                    if (hookResult !== undefined) {
-                        result = hookResult;
-                    }
-                }
-                catch (err) {
-                    console.error(`Plugin ${plugin.name} error in ${hook}: ${err}`);
-                }
-            }
-        }
-        return result;
-    }
-    async onInit() {
-        await this.runHook('onInit');
-    }
-    async onBeforeScan() {
-        await this.runHook('onBeforeScan');
-    }
-    async onAfterScan(elements) {
-        return (await this.runHook('onAfterScan', elements)) || elements;
-    }
-    async onBeforeGenerate(elements) {
-        return (await this.runHook('onBeforeGenerate', elements)) || elements;
-    }
-    async onAfterGenerate(docs) {
-        return (await this.runHook('onAfterGenerate', docs)) || docs;
-    }
-    async onBeforeWrite(docs) {
-        return (await this.runHook('onBeforeWrite', docs)) || docs;
-    }
-    async onAfterWrite() {
-        await this.runHook('onAfterWrite');
-    }
-    async transformContent(content, filePath) {
-        let result = content;
-        for (const plugin of this.plugins) {
-            if (typeof plugin.transformContent === 'function') {
-                try {
-                    result = await plugin.transformContent(result, filePath);
-                }
-                catch (err) {
-                    console.error(`Plugin ${plugin.name} error in transformContent: ${err}`);
-                }
-            }
-        }
-        return result;
-    }
-}
-// Built-in plugins
-export const builtinPlugins = {
-    // Add timestamp to generated files
-    timestamp: {
-        name: 'timestamp',
-        transformContent: (content) => {
-            const timestamp = new Date().toISOString();
-            return content.replace(/^(---\n)/, `$1generated_at: "${timestamp}"\n`);
-        },
-    },
-    // Add "Edit on GitHub" links
-    editOnGithub: (repoUrl, branch = 'main') => ({
-        name: 'edit-on-github',
-        transformContent: (content, filePath) => {
-            const editUrl = `${repoUrl}/edit/${branch}/${filePath}`;
-            return content.replace(/^(---\n[\s\S]*?---\n)/, `$1\n<EditOnGithub url="${editUrl}" />\n`);
-        },
-    }),
-    // Auto-generate table of contents
-    toc: {
-        name: 'toc',
-        transformContent: (content) => {
-            const headings = [];
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const match = line.match(/^(#{2,4})\s+(.+)$/);
-                if (match) {
-                    const level = match[1].length;
-                    const text = match[2];
-                    const anchor = text.toLowerCase().replace(/[^\w]+/g, '-');
-                    headings.push({ level, text, anchor });
-                }
-            }
-            if (headings.length < 2)
-                return content;
-            const toc = headings
-                .map(h => `${'  '.repeat(h.level - 2)}- [${h.text}](#${h.anchor})`)
-                .join('\n');
-            return content.replace(/^(---\n[\s\S]*?---\n)/, `$1\n## Table of Contents\n\n${toc}\n\n`);
-        },
-    },
-};
-export function definePlugin(plugin) {
-    return plugin;
-}

package/dist/scanner/content-type.test.d.ts

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

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

@@ -1,231 +0,0 @@
-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/integration.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Integration tests for the full scanning pipeline
- */
-export {};