skrypt-ai 0.2.0 → 0.3.0

package/dist/cli.js

@@ -15,7 +15,10 @@ import { sdkCommand } from './commands/sdk.js';
 import { ghActionCommand } from './commands/gh-action.js';
 import { llmsTxtCommand } from './commands/llms-txt.js';
 import { loginCommand, logoutCommand, whoamiCommand } from './commands/login.js';
-const VERSION = '0.2.0';
+import { cronCommand } from './commands/cron.js';
+import { deployCommand } from './commands/deploy.js';
+import { testCommand } from './commands/test.js';
+const VERSION = '0.3.0';
 async function checkForUpdates() {
     try {
         const res = await fetch('https://registry.npmjs.org/skrypt-ai/latest', {
@@ -59,4 +62,7 @@ program.addCommand(llmsTxtCommand);
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);
+program.addCommand(cronCommand);
+program.addCommand(deployCommand);
+program.addCommand(testCommand);
 program.parse();

package/dist/commands/cron.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const cronCommand: Command;

package/dist/commands/cron.js

@@ -0,0 +1,106 @@
+import { Command } from 'commander';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { resolve, join } from 'path';
+const CRON_WORKFLOW = `name: Skrypt Auto-Update Docs
+
+on:
+  # Run daily at 2am UTC - adjust as needed
+  schedule:
+    - cron: '0 2 * * *'
+
+  # Run on push to main
+  push:
+    branches: [main]
+    paths:
+      - 'src/**'
+      - 'lib/**'
+      - 'app/**'
+
+  # Allow manual trigger
+  workflow_dispatch:
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Skrypt
+        run: npm install -g skrypt-ai
+
+      - name: Generate docs
+        env:
+          OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          skrypt generate ./src --output ./docs
+
+      - name: Deploy to Skrypt
+        env:
+          SKRYPT_API_KEY: \${{ secrets.SKRYPT_API_KEY }}
+        run: |
+          skrypt deploy ./docs --project \${{ github.event.repository.name }}
+`;
+export const cronCommand = new Command('cron')
+    .description('Set up automated documentation updates with GitHub Actions')
+    .argument('[repo-path]', 'Repository path', '.')
+    .option('-s, --schedule <cron>', 'Cron schedule (default: daily at 2am UTC)', '0 2 * * *')
+    .option('-f, --force', 'Overwrite existing workflow')
+    .action(async (repoPath, options) => {
+    const resolvedPath = resolve(repoPath);
+    const workflowDir = join(resolvedPath, '.github', 'workflows');
+    const workflowPath = join(workflowDir, 'skrypt-docs.yml');
+    console.log('skrypt cron');
+    console.log(`  repo: ${resolvedPath}`);
+    console.log(`  schedule: ${options.schedule}`);
+    console.log('');
+    // Check if workflow exists
+    if (existsSync(workflowPath) && !options.force) {
+        console.log('Workflow already exists. Use --force to overwrite.');
+        console.log(`  ${workflowPath}`);
+        return;
+    }
+    // Create workflow directory
+    mkdirSync(workflowDir, { recursive: true });
+    // Customize schedule if provided
+    let workflow = CRON_WORKFLOW;
+    if (options.schedule && options.schedule !== '0 2 * * *') {
+        workflow = workflow.replace("cron: '0 2 * * *'", `cron: '${options.schedule}'`);
+    }
+    // Write workflow
+    writeFileSync(workflowPath, workflow);
+    console.log(`✓ Created: ${workflowPath}`);
+    console.log('');
+    console.log('=== Setup Instructions ===');
+    console.log('');
+    console.log('1. Add secrets to your GitHub repository:');
+    console.log('   Settings > Secrets and variables > Actions');
+    console.log('');
+    console.log('   Required:');
+    console.log('   - SKRYPT_API_KEY: Get from https://skrypt.sh/dashboard/settings');
+    console.log('');
+    console.log('   For AI generation (one of):');
+    console.log('   - OPENAI_API_KEY');
+    console.log('   - ANTHROPIC_API_KEY');
+    console.log('');
+    console.log('2. Commit and push:');
+    console.log('   git add .github/');
+    console.log('   git commit -m "Add Skrypt auto-update workflow"');
+    console.log('   git push');
+    console.log('');
+    console.log('3. Trigger manually (optional):');
+    console.log('   Go to Actions > Skrypt Auto-Update Docs > Run workflow');
+    console.log('');
+    console.log('Common schedules:');
+    console.log('   "0 2 * * *"     - Daily at 2am UTC');
+    console.log('   "0 2 * * 1"     - Weekly on Monday');
+    console.log('   "0 2 1 * *"     - Monthly on the 1st');
+    console.log('   "0 */6 * * *"   - Every 6 hours');
+});

package/dist/commands/deploy.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const deployCommand: Command;

package/dist/commands/deploy.js

@@ -0,0 +1,317 @@
+import { Command } from 'commander';
+import { execSync, spawn } from 'child_process';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+const API_BASE = process.env.SKRYPT_API_URL || 'https://api.skrypt.sh';
+/**
+ * Get API token from options, env var, or auth config
+ */
+function getApiToken(options) {
+    // 1. CLI flag
+    if (options.token) {
+        return options.token;
+    }
+    // 2. Environment variable
+    if (process.env.SKRYPT_API_KEY) {
+        return process.env.SKRYPT_API_KEY;
+    }
+    // 3. Auth config file
+    try {
+        const authFile = join(homedir(), '.skrypt', 'auth.json');
+        if (existsSync(authFile)) {
+            const config = JSON.parse(readFileSync(authFile, 'utf-8'));
+            if (config.apiKey) {
+                return config.apiKey;
+            }
+        }
+    }
+    catch {
+        // Ignore auth file errors
+    }
+    return null;
+}
+/**
+ * Get project slug from options or docs.json
+ */
+function getProjectSlug(options, docsPath) {
+    // 1. CLI flag
+    if (options.project) {
+        return options.project;
+    }
+    // 2. docs.json
+    const docsJsonPath = join(docsPath, 'docs.json');
+    if (existsSync(docsJsonPath)) {
+        try {
+            const docsJson = JSON.parse(readFileSync(docsJsonPath, 'utf-8'));
+            if (docsJson.slug) {
+                return docsJson.slug;
+            }
+            // Fallback to name, slugified
+            if (docsJson.name) {
+                return docsJson.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 3. package.json name
+    const packageJsonPath = join(docsPath, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            if (packageJson.name) {
+                return packageJson.name.replace(/^@[^/]+\//, '').toLowerCase().replace(/[^a-z0-9-]/g, '-');
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return null;
+}
+/**
+ * Run next build and return the output directory
+ */
+async function buildSite(docsPath) {
+    const outDir = join(docsPath, 'out');
+    console.log('  Running next build...');
+    return new Promise((resolve, reject) => {
+        const child = spawn('npm', ['run', 'build'], {
+            cwd: docsPath,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true
+        });
+        child.stdout?.on('data', (data) => {
+            process.stdout.write(`  ${data.toString().trim()}\n`);
+        });
+        child.stderr?.on('data', (data) => {
+            // Filter out noise
+            const line = data.toString().trim();
+            if (line && !line.includes('ExperimentalWarning')) {
+                process.stderr.write(`  ${line}\n`);
+            }
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Build failed with exit code ${code}`));
+                return;
+            }
+            resolve(outDir);
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * Create a tar.gz bundle of the build output
+ */
+async function bundleOutput(outDir) {
+    const bundlePath = join(outDir, '..', 'deploy-bundle.tar.gz');
+    console.log('  Creating deployment bundle...');
+    // Use tar to create a gzipped tarball
+    execSync(`tar -czf "${bundlePath}" -C "${outDir}" .`, {
+        stdio: 'pipe'
+    });
+    const stats = statSync(bundlePath);
+    const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+    console.log(`  Bundle size: ${sizeMB} MB`);
+    return bundlePath;
+}
+/**
+ * Upload the bundle to the API with progress
+ */
+async function uploadBundle(bundlePath, projectSlug, apiToken) {
+    const fileBuffer = readFileSync(bundlePath);
+    console.log('  Uploading to Skrypt...');
+    // Calculate checksum
+    const checksum = createHash('sha256').update(fileBuffer).digest('hex');
+    // Create form data manually for fetch
+    const boundary = `----WebKitFormBoundary${Date.now()}`;
+    const formDataParts = [];
+    // Add project slug field
+    formDataParts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="project"\r\n\r\n` +
+        `${projectSlug}\r\n`));
+    // Add checksum field
+    formDataParts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="checksum"\r\n\r\n` +
+        `${checksum}\r\n`));
+    // Add file field
+    formDataParts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="bundle"; filename="deploy-bundle.tar.gz"\r\n` +
+        `Content-Type: application/gzip\r\n\r\n`));
+    formDataParts.push(fileBuffer);
+    formDataParts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+    const body = Buffer.concat(formDataParts);
+    // Show upload progress
+    let uploadedBytes = 0;
+    const totalBytes = body.length;
+    const progressInterval = setInterval(() => {
+        // Simulate progress since fetch doesn't provide upload progress
+        uploadedBytes = Math.min(uploadedBytes + Math.floor(totalBytes / 10), totalBytes);
+        const percent = Math.round((uploadedBytes / totalBytes) * 100);
+        process.stdout.write(`\r  Uploading: ${percent}%`);
+    }, 200);
+    try {
+        const response = await fetch(`${API_BASE}/v1/deploy`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiToken}`,
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': body.length.toString()
+            },
+            body
+        });
+        clearInterval(progressInterval);
+        process.stdout.write(`\r  Uploading: 100%\n`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            let errorJson = {};
+            try {
+                errorJson = JSON.parse(errorText);
+            }
+            catch {
+                // Not JSON
+            }
+            return {
+                success: false,
+                error: errorJson.error || errorJson.message || `HTTP ${response.status}: ${response.statusText}`
+            };
+        }
+        const result = await response.json();
+        return {
+            success: true,
+            url: result.url,
+            customDomain: result.customDomain,
+            message: result.message
+        };
+    }
+    catch (err) {
+        clearInterval(progressInterval);
+        console.log('');
+        return {
+            success: false,
+            error: err instanceof Error ? err.message : 'Upload failed'
+        };
+    }
+}
+export const deployCommand = new Command('deploy')
+    .description('Deploy documentation site to Skrypt hosting')
+    .argument('[directory]', 'Documentation site directory', '.')
+    .option('--project <slug>', 'Project slug (e.g., my-docs)')
+    .option('--token <key>', 'API token (or set SKRYPT_API_KEY env var)')
+    .action(async (directory, options) => {
+    const startTime = Date.now();
+    const docsPath = resolve(directory);
+    console.log('skrypt deploy');
+    console.log(`  directory: ${docsPath}`);
+    console.log('');
+    // Validate directory
+    if (!existsSync(docsPath)) {
+        console.error(`Error: Directory not found: ${docsPath}`);
+        process.exit(1);
+    }
+    // Check for package.json (Next.js project)
+    const packageJsonPath = join(docsPath, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        console.error('Error: No package.json found. Is this a Skrypt docs site?');
+        console.error('  Run: skrypt init <directory>');
+        process.exit(1);
+    }
+    // Get API token
+    const apiToken = getApiToken(options);
+    if (!apiToken) {
+        console.error('Error: No API token found.');
+        console.error('');
+        console.error('  Provide a token using one of:');
+        console.error('    --token <key>');
+        console.error('    SKRYPT_API_KEY environment variable');
+        console.error('    skrypt login');
+        console.error('');
+        process.exit(1);
+    }
+    // Get project slug
+    const projectSlug = getProjectSlug(options, docsPath);
+    if (!projectSlug) {
+        console.error('Error: No project slug found.');
+        console.error('');
+        console.error('  Provide a project slug using one of:');
+        console.error('    --project <slug>');
+        console.error('    "slug" field in docs.json');
+        console.error('');
+        process.exit(1);
+    }
+    console.log(`  project: ${projectSlug}`);
+    console.log('');
+    // Step 1: Build the site
+    console.log('Step 1: Building documentation site...');
+    let outDir;
+    try {
+        outDir = await buildSite(docsPath);
+    }
+    catch (err) {
+        console.error('');
+        console.error(`Error: Build failed`);
+        if (err instanceof Error) {
+            console.error(`  ${err.message}`);
+        }
+        process.exit(1);
+    }
+    // Check build output exists
+    if (!existsSync(outDir)) {
+        // Try .next/static for non-static export
+        const nextDir = join(docsPath, '.next');
+        if (existsSync(nextDir)) {
+            console.error('');
+            console.error('Error: Static export not found.');
+            console.error('  Add to next.config.mjs: output: "export"');
+            process.exit(1);
+        }
+        console.error('');
+        console.error('Error: Build output not found.');
+        process.exit(1);
+    }
+    console.log('  Build completed successfully');
+    console.log('');
+    // Step 2: Bundle the output
+    console.log('Step 2: Creating deployment bundle...');
+    let bundlePath;
+    try {
+        bundlePath = await bundleOutput(outDir);
+    }
+    catch (err) {
+        console.error('');
+        console.error('Error: Failed to create bundle');
+        if (err instanceof Error) {
+            console.error(`  ${err.message}`);
+        }
+        process.exit(1);
+    }
+    console.log('');
+    // Step 3: Upload
+    console.log('Step 3: Deploying to Skrypt...');
+    const result = await uploadBundle(bundlePath, projectSlug, apiToken);
+    if (!result.success) {
+        console.error('');
+        console.error(`Error: Deployment failed`);
+        console.error(`  ${result.error}`);
+        process.exit(1);
+    }
+    // Success
+    const duration = Math.round((Date.now() - startTime) / 1000);
+    console.log('');
+    console.log('=== Deployment Successful ===');
+    console.log('');
+    console.log(`  URL: ${result.url}`);
+    if (result.customDomain) {
+        console.log(`  Custom domain: ${result.customDomain}`);
+    }
+    console.log(`  Duration: ${duration}s`);
+    console.log('');
+    console.log('Your documentation is now live!');
+    console.log('');
+});

package/dist/commands/test.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const testCommand: Command;

package/dist/commands/test.js

@@ -0,0 +1,335 @@
+import { Command } from 'commander';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { resolve, join, extname, relative } from 'path';
+import { spawn } from 'child_process';
+import { writeFileSync, unlinkSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import { requirePro } from '../auth/index.js';
+const SUPPORTED_LANGUAGES = ['typescript', 'ts', 'javascript', 'js', 'python', 'py'];
+/**
+ * Find all MDX/MD files in a directory recursively
+ */
+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;
+}
+/**
+ * Extract code blocks from a markdown/MDX file
+ */
+function extractCodeBlocks(filePath, languageFilter) {
+    const content = readFileSync(filePath, 'utf-8');
+    const blocks = [];
+    const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockRegex.exec(content)) !== null) {
+        const language = match[1] || '';
+        const code = match[2] || '';
+        // Skip if language filter is set and doesn't match
+        if (languageFilter && !language.toLowerCase().startsWith(languageFilter.toLowerCase())) {
+            continue;
+        }
+        // Skip unsupported languages
+        if (!SUPPORTED_LANGUAGES.includes(language.toLowerCase())) {
+            continue;
+        }
+        // Calculate line number
+        const beforeMatch = content.substring(0, match.index);
+        const lineNumber = beforeMatch.split('\n').length;
+        blocks.push({
+            code: code.trim(),
+            language: language.toLowerCase(),
+            file: filePath,
+            line: lineNumber,
+            index: blocks.length,
+        });
+    }
+    return blocks;
+}
+/**
+ * Run a code block in an isolated environment with timeout
+ */
+async function runCodeBlock(block, timeoutMs) {
+    const startTime = Date.now();
+    const tempDir = join(tmpdir(), `skrypt-test-${randomUUID()}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+        const isTypeScript = ['typescript', 'ts'].includes(block.language);
+        const isPython = ['python', 'py'].includes(block.language);
+        const isJavaScript = ['javascript', 'js'].includes(block.language);
+        let tempFile;
+        let command;
+        let args;
+        if (isTypeScript) {
+            tempFile = join(tempDir, 'test.ts');
+            writeFileSync(tempFile, block.code);
+            // Use tsx for TypeScript execution
+            command = 'npx';
+            args = ['tsx', tempFile];
+        }
+        else if (isJavaScript) {
+            tempFile = join(tempDir, 'test.js');
+            writeFileSync(tempFile, block.code);
+            command = 'node';
+            args = [tempFile];
+        }
+        else if (isPython) {
+            tempFile = join(tempDir, 'test.py');
+            writeFileSync(tempFile, block.code);
+            command = 'python3';
+            args = [tempFile];
+        }
+        else {
+            return {
+                block,
+                passed: false,
+                error: `Unsupported language: ${block.language}`,
+                duration: Date.now() - startTime,
+            };
+        }
+        const result = await executeWithTimeout(command, args, timeoutMs, tempDir);
+        const duration = Date.now() - startTime;
+        return {
+            block,
+            passed: result.exitCode === 0,
+            output: result.stdout,
+            error: result.stderr || (result.exitCode !== 0 ? `Exit code: ${result.exitCode}` : undefined),
+            duration,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            block,
+            passed: false,
+            error: message,
+            duration: Date.now() - startTime,
+        };
+    }
+    finally {
+        // Cleanup temp directory
+        try {
+            const files = readdirSync(tempDir);
+            for (const file of files) {
+                unlinkSync(join(tempDir, file));
+            }
+            readdirSync(tempDir); // Verify empty
+            // Remove the directory
+            const { rmdirSync } = await import('fs');
+            rmdirSync(tempDir);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Execute a command with timeout
+ */
+function executeWithTimeout(command, args, timeoutMs, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, args, {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, NODE_NO_WARNINGS: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        const timeout = setTimeout(() => {
+            killed = true;
+            proc.kill('SIGKILL');
+        }, timeoutMs);
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            if (killed) {
+                resolve({
+                    exitCode: 1,
+                    stdout,
+                    stderr: `Timeout: code execution exceeded ${timeoutMs}ms`,
+                });
+            }
+            else {
+                resolve({
+                    exitCode: code ?? 1,
+                    stdout,
+                    stderr,
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            resolve({
+                exitCode: 1,
+                stdout,
+                stderr: err.message,
+            });
+        });
+    });
+}
+/**
+ * Format duration in human-readable format
+ */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+/**
+ * Print test result
+ */
+function printResult(result, basePath, verbose) {
+    const relPath = relative(basePath, result.block.file);
+    const location = `${relPath}:${result.block.line}`;
+    const lang = result.block.language;
+    if (result.passed) {
+        console.log(`  \x1b[32m✓\x1b[0m ${location} [${lang}] (${formatDuration(result.duration)})`);
+        if (verbose && result.output) {
+            console.log(`    \x1b[90mOutput: ${result.output.trim().slice(0, 100)}${result.output.length > 100 ? '...' : ''}\x1b[0m`);
+        }
+    }
+    else {
+        console.log(`  \x1b[31m✗\x1b[0m ${location} [${lang}] (${formatDuration(result.duration)})`);
+        if (result.error) {
+            const errorLines = result.error.trim().split('\n').slice(0, 3);
+            for (const line of errorLines) {
+                console.log(`    \x1b[31m${line}\x1b[0m`);
+            }
+        }
+    }
+}
+/**
+ * Print summary
+ */
+function printSummary(summary) {
+    console.log('');
+    console.log('=== Test Summary ===');
+    console.log(`  Total:    ${summary.total}`);
+    console.log(`  \x1b[32mPassed:\x1b[0m   ${summary.passed}`);
+    console.log(`  \x1b[31mFailed:\x1b[0m   ${summary.failed}`);
+    if (summary.skipped > 0) {
+        console.log(`  \x1b[33mSkipped:\x1b[0m  ${summary.skipped}`);
+    }
+    console.log(`  Duration: ${formatDuration(summary.duration)}`);
+}
+export const testCommand = new Command('test')
+    .description('Test code examples in documentation files')
+    .argument('[path]', 'Directory or file to test', '.')
+    .option('-f, --file <file>', 'Test a specific file or directory')
+    .option('-l, --language <lang>', 'Filter by language (typescript, javascript, python)')
+    .option('--fix', 'Auto-fix failing examples using autofix command')
+    .option('-t, --timeout <ms>', 'Timeout per code block in milliseconds', '10000')
+    .option('-v, --verbose', 'Show detailed output')
+    .action(async (path, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('test')) {
+        process.exit(1);
+    }
+    const targetPath = resolve(options.file || path);
+    if (!existsSync(targetPath)) {
+        console.error(`Error: Path not found: ${targetPath}`);
+        process.exit(1);
+    }
+    const timeoutMs = parseInt(options.timeout);
+    if (isNaN(timeoutMs) || timeoutMs <= 0) {
+        console.error(`Error: Invalid timeout value: ${options.timeout}`);
+        process.exit(1);
+    }
+    console.log('skrypt test');
+    console.log(`  path: ${targetPath}`);
+    if (options.language) {
+        console.log(`  language: ${options.language}`);
+    }
+    console.log(`  timeout: ${timeoutMs}ms`);
+    console.log('');
+    // Find all doc files
+    const files = statSync(targetPath).isDirectory()
+        ? findDocFiles(targetPath)
+        : [targetPath];
+    if (files.length === 0) {
+        console.log('No .md or .mdx files found.');
+        process.exit(0);
+    }
+    // Extract all code blocks
+    const allBlocks = [];
+    for (const file of files) {
+        const blocks = extractCodeBlocks(file, options.language);
+        allBlocks.push(...blocks);
+    }
+    if (allBlocks.length === 0) {
+        console.log('No testable code blocks found.');
+        if (options.language) {
+            console.log(`  (filtered by language: ${options.language})`);
+        }
+        console.log(`  Supported languages: ${SUPPORTED_LANGUAGES.join(', ')}`);
+        process.exit(0);
+    }
+    console.log(`Found ${allBlocks.length} code block(s) in ${files.length} file(s)`);
+    console.log('');
+    console.log('Running tests...\n');
+    const results = [];
+    const failedBlocks = [];
+    const startTime = Date.now();
+    for (let i = 0; i < allBlocks.length; i++) {
+        const block = allBlocks[i];
+        if (!block)
+            continue;
+        const result = await runCodeBlock(block, timeoutMs);
+        results.push(result);
+        printResult(result, targetPath, options.verbose || false);
+        if (!result.passed) {
+            failedBlocks.push(block);
+        }
+    }
+    const totalDuration = Date.now() - startTime;
+    const summary = {
+        total: allBlocks.length,
+        passed: results.filter(r => r.passed).length,
+        failed: results.filter(r => !r.passed).length,
+        skipped: 0,
+        duration: totalDuration,
+    };
+    printSummary(summary);
+    // Handle --fix flag
+    if (options.fix && failedBlocks.length > 0) {
+        console.log('');
+        console.log('Attempting to auto-fix failing examples...');
+        console.log('  Run: skrypt autofix <file> for each failing file');
+        console.log('');
+        // Get unique files with failures
+        const failedFiles = [...new Set(failedBlocks.map(b => b.file))];
+        for (const file of failedFiles) {
+            console.log(`  → ${relative(targetPath, file)}`);
+        }
+        console.log('');
+        console.log('To auto-fix, run:');
+        for (const file of failedFiles) {
+            console.log(`  skrypt autofix "${file}"`);
+        }
+    }
+    // Exit with error code if tests failed
+    if (summary.failed > 0) {
+        process.exit(1);
+    }
+    console.log('\nAll tests passed!');
+});

package/dist/template/.github/workflows/skrypt-cron.yml

@@ -0,0 +1,60 @@
+name: Skrypt Auto-Update Docs
+
+on:
+  # Run daily at 2am UTC
+  schedule:
+    - cron: '0 2 * * *'
+
+  # Run on push to main (optional)
+  push:
+    branches: [main]
+    paths:
+      - 'src/**'
+      - 'lib/**'
+      - 'app/**'
+
+  # Allow manual trigger
+  workflow_dispatch:
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Skrypt
+        run: npm install -g skrypt-ai
+
+      - name: Generate docs
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          skrypt generate ./src --output ./docs
+
+      - name: Build docs site
+        run: |
+          cd docs
+          npm install
+          npm run build
+
+      - name: Deploy to Skrypt
+        env:
+          SKRYPT_API_KEY: ${{ secrets.SKRYPT_API_KEY }}
+        run: |
+          skrypt deploy ./docs --project ${{ github.event.repository.name }}
+
+      - name: Commit changes (optional)
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add docs/
+          git diff --staged --quiet || git commit -m "docs: auto-update documentation [skip ci]"
+          git push

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skrypt-ai",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI-powered documentation generator with code examples",
   "type": "module",
   "main": "dist/cli.js",