skrypt-ai 0.1.9 → 0.3.0

package/LICENSE

@@ -0,0 +1,92 @@
+Elastic License 2.0
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company
+makes such a claim, your patent license ends immediately for work on behalf
+of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not
+licensed, and your licenses will automatically terminate. If the licensor
+provides you with a notice of your violation, and you cease all violation of
+this license no later than 30 days after you receive that notice, your
+licenses will be reinstated retroactively. However, if you violate these
+terms after such reinstatement, any additional violation of these terms will
+cause your licenses to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is Skrypt Inc.
+
+The **software** is the software the licensor makes available under these
+terms, including any portion of it.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**Control** means ownership of substantially all the assets of an entity, or
+the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.
+
+**Trademark** means trademarks, service marks, and similar rights.

package/dist/auth/index.d.ts

@@ -0,0 +1,21 @@
+interface AuthConfig {
+    apiKey?: string;
+    email?: string;
+    plan?: 'free' | 'pro';
+    expiresAt?: string;
+}
+interface PlanCheckResponse {
+    valid: boolean;
+    plan: 'free' | 'pro';
+    email: string;
+    expiresAt?: string;
+    error?: string;
+}
+export declare function getAuthConfig(): AuthConfig;
+export declare function saveAuthConfig(config: AuthConfig): void;
+export declare function clearAuth(): void;
+export declare function checkPlan(apiKey: string): Promise<PlanCheckResponse>;
+export declare function requirePro(commandName: string): Promise<boolean>;
+export declare const PRO_COMMANDS: string[];
+export declare function isProCommand(command: string): boolean;
+export {};

package/dist/auth/index.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const CONFIG_DIR = join(homedir(), '.skrypt');
+const AUTH_FILE = join(CONFIG_DIR, 'auth.json');
+const API_BASE = process.env.SKRYPT_API_URL || 'https://api.skrypt.sh';
+export function getAuthConfig() {
+    if (!existsSync(AUTH_FILE)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(AUTH_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveAuthConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(config, null, 2));
+}
+export function clearAuth() {
+    if (existsSync(AUTH_FILE)) {
+        writeFileSync(AUTH_FILE, '{}');
+    }
+}
+export async function checkPlan(apiKey) {
+    try {
+        const response = await fetch(`${API_BASE}/v1/plan`, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            return { valid: false, plan: 'free', email: '', error: 'Invalid API key' };
+        }
+        return await response.json();
+    }
+    catch {
+        return { valid: false, plan: 'free', email: '', error: 'Failed to connect to API' };
+    }
+}
+export async function requirePro(commandName) {
+    const config = getAuthConfig();
+    if (!config.apiKey) {
+        console.error(`\n  ⚡ ${commandName} requires Skrypt Pro\n`);
+        console.error('  Get started:');
+        console.error('    1. Sign up at https://skrypt.sh/pro');
+        console.error('    2. Run: skrypt login\n');
+        console.error('  Or use SKRYPT_API_KEY environment variable\n');
+        return false;
+    }
+    // Check if we have a cached valid plan
+    if (config.plan === 'pro' && config.expiresAt) {
+        const expires = new Date(config.expiresAt);
+        if (expires > new Date()) {
+            return true;
+        }
+    }
+    // Verify with API
+    console.log('  Verifying Pro subscription...');
+    const result = await checkPlan(config.apiKey);
+    if (!result.valid || result.plan !== 'pro') {
+        console.error(`\n  ⚡ ${commandName} requires Skrypt Pro\n`);
+        if (result.error) {
+            console.error(`  Error: ${result.error}`);
+        }
+        console.error('  Upgrade at https://skrypt.sh/pro\n');
+        return false;
+    }
+    // Cache the result for 1 hour
+    saveAuthConfig({
+        ...config,
+        plan: result.plan,
+        email: result.email,
+        expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString()
+    });
+    return true;
+}
+// Pro commands list
+export const PRO_COMMANDS = [
+    'monitor',
+    'autofix',
+    'heal',
+    'test',
+    'sdk',
+    'gh-action',
+    'ci',
+    'mcp'
+];
+export function isProCommand(command) {
+    return PRO_COMMANDS.includes(command);
+}

package/dist/cli.js

@@ -14,7 +14,11 @@ import { monitorCommand } from './commands/monitor.js';
 import { sdkCommand } from './commands/sdk.js';
 import { ghActionCommand } from './commands/gh-action.js';
 import { llmsTxtCommand } from './commands/llms-txt.js';
-const VERSION = '0.1.9';
+import { loginCommand, logoutCommand, whoamiCommand } from './commands/login.js';
+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', {
@@ -55,4 +59,10 @@ program.addCommand(monitorCommand);
 program.addCommand(sdkCommand);
 program.addCommand(ghActionCommand);
 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/autofix.js

@@ -4,6 +4,7 @@ import { resolve } from 'path';
 import { loadConfig, checkApiKey } from '../config/index.js';
 import { createLLMClient } from '../llm/index.js';
 import { autoFixExample, createTypeScriptValidator, createPythonValidator } from '../autofix/index.js';
+import { requirePro } from '../auth/index.js';
 export const autofixCommand = new Command('autofix')
     .description('Auto-fix broken code examples in documentation')
     .argument('<file>', 'Documentation file to fix (markdown/mdx)')
@@ -14,6 +15,10 @@ export const autofixCommand = new Command('autofix')
     .option('--dry-run', 'Show fixes without writing')
     .option('--language <lang>', 'Force language for validation')
     .action(async (file, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('autofix')) {
+        process.exit(1);
+    }
     const config = loadConfig(options.config);
     if (options.provider)
         config.llm.provider = options.provider;

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/gh-action.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { resolve, join } from 'path';
+import { requirePro } from '../auth/index.js';
 const GITHUB_ACTION_WORKFLOW = `name: Skrypt Documentation Check
 
 on:
@@ -162,6 +163,10 @@ export const ghActionCommand = new Command('gh-action')
     .argument('[repo-path]', 'Repository path', '.')
     .option('-f, --force', 'Overwrite existing workflow')
     .action(async (repoPath, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('gh-action')) {
+        process.exit(1);
+    }
     const resolvedPath = resolve(repoPath);
     const workflowDir = join(resolvedPath, '.github', 'workflows');
     const workflowPath = join(workflowDir, 'skrypt-docs.yml');

package/dist/commands/login.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare const loginCommand: Command;
+export declare const logoutCommand: Command;
+export declare const whoamiCommand: Command;

package/dist/commands/login.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import { saveAuthConfig, getAuthConfig, clearAuth, checkPlan } from '../auth/index.js';
+import * as readline from 'readline';
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export const loginCommand = new Command('login')
+    .description('Login to Skrypt Pro')
+    .option('--key <api-key>', 'API key (or set SKRYPT_API_KEY env var)')
+    .action(async (options) => {
+    console.log('skrypt login\n');
+    let apiKey = options.key || process.env.SKRYPT_API_KEY;
+    if (!apiKey) {
+        console.log('  Get your API key at: https://skrypt.sh/dashboard/settings\n');
+        apiKey = await prompt('  Enter API key: ');
+    }
+    if (!apiKey) {
+        console.error('  Error: No API key provided');
+        process.exit(1);
+    }
+    console.log('\n  Verifying...');
+    const result = await checkPlan(apiKey);
+    if (!result.valid) {
+        console.error(`\n  Error: ${result.error || 'Invalid API key'}`);
+        process.exit(1);
+    }
+    saveAuthConfig({
+        apiKey,
+        email: result.email,
+        plan: result.plan,
+        expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString()
+    });
+    console.log(`\n  ✓ Logged in as ${result.email}`);
+    console.log(`  Plan: ${result.plan.toUpperCase()}\n`);
+    if (result.plan === 'free') {
+        console.log('  Upgrade to Pro: https://skrypt.sh/pro\n');
+    }
+});
+export const logoutCommand = new Command('logout')
+    .description('Logout from Skrypt')
+    .action(async () => {
+    clearAuth();
+    console.log('  Logged out successfully\n');
+});
+export const whoamiCommand = new Command('whoami')
+    .description('Show current login status')
+    .action(async () => {
+    const config = getAuthConfig();
+    if (!config.apiKey) {
+        console.log('  Not logged in');
+        console.log('  Run: skrypt login\n');
+        return;
+    }
+    console.log(`  Email: ${config.email || 'Unknown'}`);
+    console.log(`  Plan: ${(config.plan || 'free').toUpperCase()}\n`);
+});

package/dist/commands/mcp.js

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { resolve, join, extname, relative } from 'path';
 import { createServer } from 'http';
+import { requirePro } from '../auth/index.js';
 function findMdxFiles(dir) {
     const files = [];
     function walk(currentDir) {
@@ -166,6 +167,10 @@ export const mcpCommand = new Command('mcp')
     .option('-h, --host <host>', 'Server host', 'localhost')
     .option('-o, --output <file>', 'Output manifest to file instead of starting server')
     .action(async (path, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('mcp')) {
+        process.exit(1);
+    }
     const targetPath = resolve(path);
     if (!existsSync(targetPath)) {
         console.error(`Error: Path not found: ${targetPath}`);

package/dist/commands/monitor.js

@@ -4,6 +4,7 @@ import { existsSync, writeFileSync, readdirSync, statSync, mkdirSync } from 'fs'
 import { resolve, join, dirname } from 'path';
 import { createLLMClient } from '../llm/index.js';
 import { loadConfig, checkApiKey } from '../config/index.js';
+import { requirePro } from '../auth/index.js';
 function getGitChanges(since, repoPath) {
     const changes = [];
     try {
@@ -177,6 +178,10 @@ export const monitorCommand = new Command('monitor')
     .option('--create-pr', 'Create a GitHub PR with changes')
     .option('--dry-run', 'Show what would be done without making changes')
     .action(async (repoPath, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('monitor')) {
+        process.exit(1);
+    }
     const resolvedPath = resolve(repoPath);
     console.log('skrypt monitor');
     console.log(`  repo: ${resolvedPath}`);

package/dist/commands/sdk.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { resolve, join, basename } from 'path';
 import { createLLMClient } from '../llm/index.js';
 import { loadConfig, checkApiKey } from '../config/index.js';
+import { requirePro } from '../auth/index.js';
 const SUPPORTED_LANGUAGES = ['typescript', 'python', 'go', 'ruby', 'php', 'java', 'curl', 'csharp'];
 const LANGUAGE_TEMPLATES = {
     typescript: `// TypeScript with fetch
@@ -222,6 +223,10 @@ export const sdkCommand = new Command('sdk')
     .option('--model <name>', 'LLM model')
     .option('--format <type>', 'Output format (markdown or json)', 'markdown')
     .action(async (specPath, options) => {
+    // Pro feature - requires subscription
+    if (!await requirePro('sdk')) {
+        process.exit(1);
+    }
     const resolvedSpec = resolve(specPath);
     if (!existsSync(resolvedSpec)) {
         console.error(`Error: Spec file not found: ${resolvedSpec}`);

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.1.9",
+  "version": "0.3.0",
   "description": "AI-powered documentation generator with code examples",
   "type": "module",
   "main": "dist/cli.js",
@@ -45,7 +45,7 @@
     "api"
   ],
   "author": "",
-  "license": "UNLICENSED",
+  "license": "Elastic-2.0",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
     "chalk": "^5.6.2",