skrypt-ai 0.1.0

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

@@ -0,0 +1,79 @@
+/**
+ * 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/llm/openai-client.d.ts

@@ -0,0 +1,17 @@
+import { LLMClient, LLMClientConfig, CompletionRequest, CompletionResponse } from './types.js';
+import { LLMProvider } from '../config/types.js';
+/**
+ * OpenAI-compatible client
+ * Works with: OpenAI, DeepSeek, Ollama, OpenRouter, Google Gemini
+ */
+export declare class OpenAICompatibleClient implements LLMClient {
+    provider: LLMProvider;
+    private client;
+    private model;
+    private maxRetries;
+    constructor(config: LLMClientConfig);
+    isConfigured(): boolean;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    private mapFinishReason;
+    private handleError;
+}

package/dist/llm/openai-client.js

@@ -0,0 +1,90 @@
+import OpenAI from 'openai';
+import { PROVIDER_BASE_URLS, PROVIDER_EXTRA_HEADERS } from './types.js';
+/**
+ * OpenAI-compatible client
+ * Works with: OpenAI, DeepSeek, Ollama, OpenRouter, Google Gemini
+ */
+export class OpenAICompatibleClient {
+    provider;
+    client;
+    model;
+    maxRetries;
+    constructor(config) {
+        this.provider = config.provider;
+        this.model = config.model;
+        this.maxRetries = config.maxRetries ?? 3;
+        const baseURL = config.baseUrl || PROVIDER_BASE_URLS[config.provider];
+        const extraHeaders = PROVIDER_EXTRA_HEADERS[config.provider] || {};
+        this.client = new OpenAI({
+            apiKey: config.apiKey || 'ollama', // Ollama doesn't need a real key
+            baseURL,
+            timeout: config.timeout ?? 60000,
+            maxRetries: this.maxRetries,
+            defaultHeaders: extraHeaders
+        });
+    }
+    isConfigured() {
+        return true; // OpenAI SDK handles validation
+    }
+    async complete(request) {
+        const model = request.model || this.model;
+        try {
+            const response = await this.client.chat.completions.create({
+                model,
+                messages: request.messages.map(m => ({
+                    role: m.role,
+                    content: m.content
+                })),
+                temperature: request.temperature ?? 0,
+                max_tokens: request.maxTokens ?? 4096
+            });
+            const choice = response.choices[0];
+            const content = choice?.message?.content || '';
+            return {
+                content,
+                model: response.model,
+                usage: {
+                    inputTokens: response.usage?.prompt_tokens ?? 0,
+                    outputTokens: response.usage?.completion_tokens ?? 0,
+                    totalTokens: response.usage?.total_tokens ?? 0
+                },
+                finishReason: this.mapFinishReason(choice?.finish_reason)
+            };
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'stop':
+            case 'end_turn':
+                return 'stop';
+            case 'length':
+            case 'max_tokens':
+                return 'length';
+            default:
+                return 'error';
+        }
+    }
+    handleError(error) {
+        if (error instanceof OpenAI.APIError) {
+            const status = error.status;
+            const message = error.message;
+            if (status === 401) {
+                return new Error(`Authentication failed for ${this.provider}: Invalid API key`);
+            }
+            if (status === 429) {
+                return new Error(`Rate limited by ${this.provider}: ${message}`);
+            }
+            if (status === 500 || status === 502 || status === 503) {
+                return new Error(`${this.provider} service error: ${message}`);
+            }
+            return new Error(`${this.provider} API error (${status}): ${message}`);
+        }
+        if (error instanceof Error) {
+            return error;
+        }
+        return new Error(`Unknown error from ${this.provider}: ${String(error)}`);
+    }
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,60 @@
+import { LLMProvider } from '../config/types.js';
+/**
+ * Message in a conversation
+ */
+export interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Request to generate a completion
+ */
+export interface CompletionRequest {
+    messages: Message[];
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+/**
+ * Response from a completion request
+ */
+export interface CompletionResponse {
+    content: string;
+    model: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    finishReason: 'stop' | 'length' | 'error';
+}
+/**
+ * LLM client configuration
+ */
+export interface LLMClientConfig {
+    provider: LLMProvider;
+    model: string;
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+/**
+ * LLM client interface
+ */
+export interface LLMClient {
+    /** The provider this client uses */
+    provider: LLMProvider;
+    /** Generate a completion */
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    /** Check if the client is properly configured */
+    isConfigured(): boolean;
+}
+/**
+ * Provider base URLs
+ */
+export declare const PROVIDER_BASE_URLS: Record<LLMProvider, string>;
+/**
+ * Extra headers needed per provider
+ */
+export declare const PROVIDER_EXTRA_HEADERS: Partial<Record<LLMProvider, Record<string, string>>>;

package/dist/llm/types.js

@@ -0,0 +1,20 @@
+/**
+ * Provider base URLs
+ */
+export const PROVIDER_BASE_URLS = {
+    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'
+};
+/**
+ * Extra headers needed per provider
+ */
+export const PROVIDER_EXTRA_HEADERS = {
+    openrouter: {
+        'HTTP-Referer': 'https://github.com/debgotwired/skrypt',
+        'X-Title': 'skrypt'
+    }
+};

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

@@ -0,0 +1,39 @@
+import { APIElement } from './types.js';
+/**
+ * Content type detection for documentation
+ * Determines if code should be documented as API reference, guide, or tutorial
+ */
+export type ContentType = 'api' | 'guide' | 'tutorial' | 'overview';
+export interface ContentClassification {
+    type: ContentType;
+    confidence: number;
+    reasons: string[];
+}
+/**
+ * Classify what type of documentation an API element needs
+ */
+export declare function classifyElement(element: APIElement): ContentClassification;
+/**
+ * Batch classify elements and group by content type
+ */
+export declare function classifyElements(elements: APIElement[]): Map<ContentType, APIElement[]>;
+/**
+ * Get recommended documentation structure for a set of elements
+ */
+export declare function getRecommendedStructure(elements: APIElement[]): {
+    sections: {
+        name: string;
+        type: ContentType;
+        elements: APIElement[];
+    }[];
+    stats: {
+        api: number;
+        guide: number;
+        tutorial: number;
+        overview: number;
+    };
+};
+/**
+ * Generate documentation prompt based on content type
+ */
+export declare function getPromptForContentType(type: ContentType): string;

package/dist/scanner/content-type.js

@@ -0,0 +1,194 @@
+/**
+ * Classify what type of documentation an API element needs
+ */
+export function classifyElement(element) {
+    const reasons = [];
+    let apiScore = 0;
+    let guideScore = 0;
+    let tutorialScore = 0;
+    // API Reference indicators
+    if (element.parameters.length >= 3) {
+        apiScore += 2;
+        reasons.push('Multiple parameters suggest API reference');
+    }
+    if (element.returnType && element.returnType.length > 10) {
+        apiScore += 1;
+        reasons.push('Complex return type');
+    }
+    if (element.kind === 'method' && element.parentClass) {
+        apiScore += 1;
+        reasons.push('Method on a class');
+    }
+    if (element.signature.includes('async') || element.signature.includes('Promise')) {
+        apiScore += 1;
+        reasons.push('Async pattern suggests API');
+    }
+    // Check for HTTP/REST patterns
+    const httpPatterns = /\b(GET|POST|PUT|DELETE|PATCH|http|request|response|fetch|axios)\b/i;
+    if (httpPatterns.test(element.signature) || httpPatterns.test(element.docstring || '')) {
+        apiScore += 3;
+        reasons.push('HTTP/REST patterns detected');
+    }
+    // Check for handler/endpoint patterns - no strict word boundaries for camelCase
+    const handlerPatterns = /(handler|endpoint|route|controller|middleware)/i;
+    if (handlerPatterns.test(element.name) || handlerPatterns.test(element.filePath)) {
+        apiScore += 2;
+        reasons.push('Handler/endpoint pattern');
+    }
+    // Guide indicators - use case-insensitive match without strict word boundaries
+    // to handle camelCase names like configureAuth, setupDatabase
+    const guidePatterns = /(config|setup|init|configure|options|settings)/i;
+    if (guidePatterns.test(element.name)) {
+        guideScore += 2;
+        reasons.push('Configuration/setup function');
+    }
+    if (element.docstring && element.docstring.length > 200) {
+        guideScore += 1;
+        reasons.push('Extensive documentation');
+    }
+    // Check for integration patterns - no strict word boundaries for camelCase
+    const integrationPatterns = /(connect|integrate|provider|client)/i;
+    if (integrationPatterns.test(element.name) || integrationPatterns.test(element.docstring || '')) {
+        guideScore += 1;
+        reasons.push('Integration pattern');
+    }
+    // Tutorial indicators
+    const tutorialPatterns = /\b(example|demo|sample|tutorial|quickstart|getting.?started)\b/i;
+    if (tutorialPatterns.test(element.filePath) || tutorialPatterns.test(element.docstring || '')) {
+        tutorialScore += 3;
+        reasons.push('Example/tutorial pattern in path or docs');
+    }
+    if (element.name.toLowerCase().includes('example') || element.name.toLowerCase().includes('demo')) {
+        tutorialScore += 2;
+        reasons.push('Name suggests example');
+    }
+    // Simple functions with few params = tutorial
+    if (element.parameters.length <= 1 && element.kind === 'function') {
+        tutorialScore += 1;
+        reasons.push('Simple function, good for tutorial');
+    }
+    // Determine winner
+    const maxScore = Math.max(apiScore, guideScore, tutorialScore);
+    const totalScore = apiScore + guideScore + tutorialScore;
+    if (maxScore === 0) {
+        return {
+            type: 'overview',
+            confidence: 0.5,
+            reasons: ['No strong indicators, defaulting to overview']
+        };
+    }
+    let type;
+    if (apiScore === maxScore) {
+        type = 'api';
+    }
+    else if (guideScore === maxScore) {
+        type = 'guide';
+    }
+    else {
+        type = 'tutorial';
+    }
+    const confidence = totalScore > 0 ? maxScore / totalScore : 0.5;
+    return { type, confidence, reasons };
+}
+/**
+ * Batch classify elements and group by content type
+ */
+export function classifyElements(elements) {
+    const groups = new Map([
+        ['api', []],
+        ['guide', []],
+        ['tutorial', []],
+        ['overview', []]
+    ]);
+    for (const element of elements) {
+        const classification = classifyElement(element);
+        const group = groups.get(classification.type);
+        group.push(element);
+    }
+    return groups;
+}
+/**
+ * Get recommended documentation structure for a set of elements
+ */
+export function getRecommendedStructure(elements) {
+    const classified = classifyElements(elements);
+    const sections = [];
+    const stats = { api: 0, guide: 0, tutorial: 0, overview: 0 };
+    // API Reference section
+    const apiElements = classified.get('api');
+    if (apiElements.length > 0) {
+        sections.push({
+            name: 'API Reference',
+            type: 'api',
+            elements: apiElements
+        });
+        stats.api = apiElements.length;
+    }
+    // Guides section
+    const guideElements = classified.get('guide');
+    if (guideElements.length > 0) {
+        sections.push({
+            name: 'Guides',
+            type: 'guide',
+            elements: guideElements
+        });
+        stats.guide = guideElements.length;
+    }
+    // Tutorials section
+    const tutorialElements = classified.get('tutorial');
+    if (tutorialElements.length > 0) {
+        sections.push({
+            name: 'Tutorials',
+            type: 'tutorial',
+            elements: tutorialElements
+        });
+        stats.tutorial = tutorialElements.length;
+    }
+    // Overview/Other
+    const overviewElements = classified.get('overview');
+    if (overviewElements.length > 0) {
+        sections.push({
+            name: 'Overview',
+            type: 'overview',
+            elements: overviewElements
+        });
+        stats.overview = overviewElements.length;
+    }
+    return { sections, stats };
+}
+/**
+ * Generate documentation prompt based on content type
+ */
+export function getPromptForContentType(type) {
+    switch (type) {
+        case 'api':
+            return `Generate detailed API reference documentation. Include:
+- Clear parameter descriptions with types
+- Return value documentation
+- Error cases and edge conditions
+- Code example showing typical usage
+Focus on technical accuracy and completeness.`;
+        case 'guide':
+            return `Generate a practical guide for this functionality. Include:
+- What problem it solves
+- Step-by-step setup instructions
+- Configuration options explained
+- Best practices and common patterns
+Focus on helping developers integrate this into their projects.`;
+        case 'tutorial':
+            return `Generate a beginner-friendly tutorial. Include:
+- What you'll learn
+- Prerequisites
+- Step-by-step walkthrough with explanations
+- Complete working example
+- Next steps for learning more
+Focus on teaching concepts through hands-on examples.`;
+        case 'overview':
+            return `Generate an overview of this functionality. Include:
+- What it does at a high level
+- When to use it
+- Basic example
+- Links to related documentation
+Keep it concise but informative.`;
+    }
+}

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

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