skrypt-ai 0.6.0 → 0.7.0

package/dist/testing/docker.js

@@ -0,0 +1,234 @@
+import { spawnSync, spawn } from 'child_process';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import { compareOutput } from './comparator.js';
+import { checkRequiredEnv } from './env.js';
+/**
+ * Available Docker environments for multi-env testing
+ */
+export const DOCKER_ENVIRONMENTS = [
+    { name: 'node-20', image: 'node:20-slim', command: 'node', languages: ['typescript', 'ts', 'javascript', 'js'] },
+    { name: 'node-18', image: 'node:18-slim', command: 'node', languages: ['typescript', 'ts', 'javascript', 'js'] },
+    { name: 'python-3.12', image: 'python:3.12-slim', command: 'python3', languages: ['python', 'py'] },
+    { name: 'python-3.10', image: 'python:3.10-slim', command: 'python3', languages: ['python', 'py'] },
+    { name: 'bun', image: 'oven/bun:latest', command: 'bun', languages: ['typescript', 'ts', 'javascript', 'js'] },
+    { name: 'deno', image: 'denoland/deno:latest', command: 'deno', languages: ['typescript', 'ts', 'javascript', 'js'] },
+];
+/**
+ * Check if Docker is available on this machine
+ */
+export function isDockerAvailable() {
+    try {
+        const result = spawnSync('docker', ['info'], {
+            stdio: 'pipe',
+            timeout: 5000,
+        });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse a comma-separated environments string into DockerEnvironment objects
+ */
+export function parseEnvironments(envString) {
+    const names = envString.split(',').map(s => s.trim()).filter(Boolean);
+    const envs = [];
+    for (const name of names) {
+        const env = DOCKER_ENVIRONMENTS.find(e => e.name === name);
+        if (env) {
+            envs.push(env);
+        }
+        else {
+            console.warn(`  Warning: Unknown environment "${name}". Available: ${DOCKER_ENVIRONMENTS.map(e => e.name).join(', ')}`);
+        }
+    }
+    return envs;
+}
+/**
+ * Get compatible Docker environments for a given language
+ */
+export function getCompatibleEnvironments(language, environments) {
+    return environments.filter(env => env.languages.includes(language));
+}
+/**
+ * Run a snippet in a Docker container
+ */
+export async function runInDocker(snippet, environment, config) {
+    const startTime = Date.now();
+    const envLabel = `docker:${environment.name}`;
+    // Check for skip directive
+    if (snippet.skipReason) {
+        return {
+            snippet,
+            status: 'skip',
+            stdout: '',
+            stderr: `Skipped: ${snippet.skipReason}`,
+            exitCode: 0,
+            duration: 0,
+            environment: envLabel,
+        };
+    }
+    // Check required env vars
+    if (snippet.requiredEnv && snippet.requiredEnv.length > 0) {
+        const { ok, missing } = checkRequiredEnv(snippet.requiredEnv, config.envVars);
+        if (!ok) {
+            return {
+                snippet,
+                status: 'skip',
+                stdout: '',
+                stderr: `Missing required env vars: ${missing.join(', ')}`,
+                exitCode: 0,
+                duration: 0,
+                environment: envLabel,
+            };
+        }
+    }
+    const tempDir = join(tmpdir(), `skrypt-docker-${randomUUID()}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+        const isTS = ['typescript', 'ts'].includes(snippet.language);
+        const isPy = ['python', 'py'].includes(snippet.language);
+        let filename;
+        let containerCmd;
+        if (isPy) {
+            filename = 'test.py';
+            containerCmd = ['python3', `/work/${filename}`];
+        }
+        else if (isTS && environment.name === 'bun') {
+            filename = 'test.ts';
+            containerCmd = ['bun', 'run', `/work/${filename}`];
+        }
+        else if (isTS && environment.name === 'deno') {
+            filename = 'test.ts';
+            containerCmd = ['deno', 'run', '--allow-all', `/work/${filename}`];
+        }
+        else if (isTS) {
+            // Node needs tsx for TypeScript
+            filename = 'test.ts';
+            containerCmd = ['npx', '-y', 'tsx', `/work/${filename}`];
+        }
+        else {
+            filename = 'test.js';
+            containerCmd = ['node', `/work/${filename}`];
+        }
+        writeFileSync(join(tempDir, filename), snippet.code);
+        // Build Docker args
+        const dockerArgs = ['run', '--rm', '-v', `${tempDir}:/work`, '-w', '/work'];
+        // Inject env vars
+        for (const [key, value] of Object.entries(config.envVars)) {
+            dockerArgs.push('-e', `${key}=${value}`);
+        }
+        dockerArgs.push(environment.image, ...containerCmd);
+        const result = await executeDocker(dockerArgs, config.timeout);
+        const duration = Date.now() - startTime;
+        // Check output if expected
+        if (snippet.expectedOutput !== undefined) {
+            const comparison = compareOutput(result.stdout, snippet.expectedOutput, snippet.expectedOutputMode || 'exact');
+            if (!comparison.match) {
+                return {
+                    snippet,
+                    status: 'output_mismatch',
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    exitCode: result.exitCode,
+                    duration,
+                    environment: envLabel,
+                    outputMatch: false,
+                    diff: comparison.diff,
+                };
+            }
+            return {
+                snippet,
+                status: result.exitCode === 0 ? 'pass' : 'fail',
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                duration,
+                environment: envLabel,
+                outputMatch: true,
+            };
+        }
+        return {
+            snippet,
+            status: result.timedOut ? 'timeout' : (result.exitCode === 0 ? 'pass' : 'fail'),
+            stdout: result.stdout,
+            stderr: result.timedOut
+                ? `Timeout: execution exceeded ${config.timeout}ms`
+                : result.stderr,
+            exitCode: result.exitCode,
+            duration,
+            environment: envLabel,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            snippet,
+            status: 'fail',
+            stdout: '',
+            stderr: message,
+            exitCode: 1,
+            duration: Date.now() - startTime,
+            environment: envLabel,
+        };
+    }
+    finally {
+        try {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+function executeDocker(args, timeoutMs) {
+    return new Promise((resolve) => {
+        const proc = spawn('docker', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const MAX_BUFFER = 1024 * 1024; // 1MB cap to prevent OOM
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            proc.kill('SIGKILL');
+        }, timeoutMs);
+        proc.stdout?.on('data', (data) => {
+            if (stdout.length < MAX_BUFFER) {
+                stdout += data.toString();
+                if (stdout.length > MAX_BUFFER)
+                    stdout = stdout.slice(0, MAX_BUFFER);
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            if (stderr.length < MAX_BUFFER) {
+                stderr += data.toString();
+                if (stderr.length > MAX_BUFFER)
+                    stderr = stderr.slice(0, MAX_BUFFER);
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            resolve({
+                exitCode: timedOut ? 1 : (code ?? 1),
+                stdout,
+                stderr,
+                timedOut,
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            resolve({
+                exitCode: 1,
+                stdout,
+                stderr: err.message,
+                timedOut: false,
+            });
+        });
+    });
+}

package/dist/testing/env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Load environment variables from a .env file
+ */
+export declare function loadEnvFile(envFilePath: string): Record<string, string>;
+/**
+ * Build a clean environment for snippet execution.
+ * Only passes PATH, HOME, and explicitly injected vars.
+ */
+export declare function buildCleanEnv(injectedVars: Record<string, string>): Record<string, string>;
+/**
+ * Check if all required env vars are present
+ */
+export declare function checkRequiredEnv(required: string[], available: Record<string, string>): {
+    ok: boolean;
+    missing: string[];
+};

package/dist/testing/env.js

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync } from 'fs';
+/**
+ * Load environment variables from a .env file
+ */
+export function loadEnvFile(envFilePath) {
+    if (!existsSync(envFilePath)) {
+        throw new Error(`Env file not found: ${envFilePath}`);
+    }
+    const content = readFileSync(envFilePath, 'utf-8');
+    const vars = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.substring(0, eqIdx).trim();
+        let value = trimmed.substring(eqIdx + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        vars[key] = value;
+    }
+    return vars;
+}
+/**
+ * Build a clean environment for snippet execution.
+ * Only passes PATH, HOME, and explicitly injected vars.
+ */
+export function buildCleanEnv(injectedVars) {
+    const clean = {
+        NODE_NO_WARNINGS: '1',
+    };
+    // Carry over PATH so runtimes can be found
+    if (process.env.PATH) {
+        clean.PATH = process.env.PATH;
+    }
+    // HOME / USERPROFILE for tools that need it
+    if (process.env.HOME) {
+        clean.HOME = process.env.HOME;
+    }
+    if (process.env.USERPROFILE) {
+        clean.USERPROFILE = process.env.USERPROFILE;
+    }
+    // Inject user-provided vars (API keys, etc.)
+    Object.assign(clean, injectedVars);
+    return clean;
+}
+/**
+ * Check if all required env vars are present
+ */
+export function checkRequiredEnv(required, available) {
+    const missing = required.filter(key => !available[key]);
+    return { ok: missing.length === 0, missing };
+}

package/dist/testing/extractor.d.ts

@@ -0,0 +1,9 @@
+import { ExtractedSnippet } from './types.js';
+/**
+ * Find all .md/.mdx files in a directory recursively
+ */
+export declare function findDocFiles(dir: string): string[];
+/**
+ * Extract code blocks from a markdown/MDX file
+ */
+export declare function extractSnippets(filePath: string, languageFilter?: string): ExtractedSnippet[];

package/dist/testing/extractor.js

@@ -0,0 +1,195 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+const SUPPORTED_LANGUAGES = ['typescript', 'ts', 'javascript', 'js', 'python', 'py'];
+/**
+ * Normalize language to canonical form for comparison
+ */
+const LANGUAGE_CANONICAL = {
+    typescript: 'typescript',
+    ts: 'typescript',
+    javascript: 'javascript',
+    js: 'javascript',
+    python: 'python',
+    py: 'python',
+};
+/**
+ * Find all .md/.mdx files in a directory recursively
+ */
+export function findDocFiles(dir) {
+    const files = [];
+    function walk(currentDir) {
+        const entries = readdirSync(currentDir);
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+                walk(fullPath);
+            }
+            else if (stat.isFile() && (extname(entry) === '.mdx' || extname(entry) === '.md')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+/**
+ * Parse a multi-line expected output block.
+ * Supports:
+ *   // Output: single line
+ *   // Output (contains): partial match
+ *   // Output:
+ *   //   line1
+ *   //   line2
+ */
+function parseExpectedOutput(code) {
+    const lines = code.split('\n');
+    let output;
+    let mode = 'exact';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Check for "// Output (contains): ..."
+        const containsMatch = line.match(/^\/\/\s*Output\s*\(contains\)\s*:\s*(.*)$/);
+        if (containsMatch) {
+            mode = 'contains';
+            const value = containsMatch[1].trim();
+            if (value) {
+                output = value;
+            }
+            else {
+                // Multi-line: collect subsequent // prefixed lines
+                output = collectMultiLineOutput(lines, i + 1);
+            }
+            break;
+        }
+        // Check for "// Output: ..."
+        const exactMatch = line.match(/^\/\/\s*Output\s*:\s*(.*)$/);
+        if (exactMatch) {
+            const value = exactMatch[1].trim();
+            if (value) {
+                output = value;
+            }
+            else {
+                output = collectMultiLineOutput(lines, i + 1);
+            }
+            break;
+        }
+        // Python: # Output: ...
+        const pyContainsMatch = line.match(/^#\s*Output\s*\(contains\)\s*:\s*(.*)$/);
+        if (pyContainsMatch) {
+            mode = 'contains';
+            const value = pyContainsMatch[1].trim();
+            if (value) {
+                output = value;
+            }
+            else {
+                output = collectMultiLineOutput(lines, i + 1, '#');
+            }
+            break;
+        }
+        const pyMatch = line.match(/^#\s*Output\s*:\s*(.*)$/);
+        if (pyMatch) {
+            const value = pyMatch[1].trim();
+            if (value) {
+                output = value;
+            }
+            else {
+                output = collectMultiLineOutput(lines, i + 1, '#');
+            }
+            break;
+        }
+    }
+    return { output, mode };
+}
+function collectMultiLineOutput(lines, startIdx, commentChar = '//') {
+    const outputLines = [];
+    for (let j = startIdx; j < lines.length; j++) {
+        const l = lines[j].trim();
+        if (commentChar === '//') {
+            if (l.startsWith('//')) {
+                outputLines.push(l.replace(/^\/\/\s?/, ''));
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            if (l.startsWith('#')) {
+                outputLines.push(l.replace(/^#\s?/, ''));
+            }
+            else {
+                break;
+            }
+        }
+    }
+    return outputLines.join('\n');
+}
+/**
+ * Parse directive comments from a code snippet
+ */
+function parseDirectives(code, language) {
+    const commentPrefix = ['python', 'py'].includes(language) ? '#' : '//';
+    const lines = code.split('\n');
+    let requiredEnv;
+    let skipReason;
+    let dependencies;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Requires: ENV_VAR1, ENV_VAR2
+        const reqMatch = trimmed.match(new RegExp(`^${commentPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*Requires:\\s*(.+)$`));
+        if (reqMatch) {
+            requiredEnv = reqMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+        }
+        // Skip: reason
+        const skipMatch = trimmed.match(new RegExp(`^${commentPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*Skip:\\s*(.+)$`));
+        if (skipMatch) {
+            skipReason = skipMatch[1].trim();
+        }
+        // Deps: pkg1, pkg2
+        const depsMatch = trimmed.match(new RegExp(`^${commentPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*Deps:\\s*(.+)$`));
+        if (depsMatch) {
+            dependencies = depsMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+        }
+    }
+    return { requiredEnv, skipReason, dependencies };
+}
+/**
+ * Extract code blocks from a markdown/MDX file
+ */
+export function extractSnippets(filePath, languageFilter) {
+    const content = readFileSync(filePath, 'utf-8');
+    const snippets = [];
+    const codeBlockRegex = /```(\w+)?[^\n]*\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockRegex.exec(content)) !== null) {
+        const language = (match[1] || '').toLowerCase();
+        const code = (match[2] || '').trim();
+        if (languageFilter) {
+            const filterCanonical = LANGUAGE_CANONICAL[languageFilter.toLowerCase()] || languageFilter.toLowerCase();
+            const langCanonical = LANGUAGE_CANONICAL[language] || language;
+            if (langCanonical !== filterCanonical) {
+                continue;
+            }
+        }
+        if (!SUPPORTED_LANGUAGES.includes(language)) {
+            continue;
+        }
+        const beforeMatch = content.substring(0, match.index);
+        const lineNumber = beforeMatch.split('\n').length;
+        const { output, mode } = parseExpectedOutput(code);
+        const directives = parseDirectives(code, language);
+        snippets.push({
+            code,
+            language,
+            filePath,
+            lineNumber,
+            index: snippets.length,
+            expectedOutput: output,
+            expectedOutputMode: mode,
+            requiredEnv: directives.requiredEnv,
+            skipReason: directives.skipReason,
+            dependencies: directives.dependencies,
+        });
+    }
+    return snippets;
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './comparator.js';
+export * from './env.js';
+export * from './runner.js';
+export * from './docker.js';

package/dist/testing/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './comparator.js';
+export * from './env.js';
+export * from './runner.js';
+export * from './docker.js';

package/dist/testing/runner.d.ts

@@ -0,0 +1,5 @@
+import { ExtractedSnippet, TestResult, RunnerConfig } from './types.js';
+/**
+ * Run a snippet locally in an isolated temp directory with a clean environment
+ */
+export declare function runLocally(snippet: ExtractedSnippet, config: RunnerConfig): Promise<TestResult>;