skrypt-ai 0.1.0

package/dist/commands/generate.js

@@ -0,0 +1,320 @@
+import { Command } from 'commander';
+import { existsSync, copyFileSync, mkdirSync, readFileSync } from 'fs';
+import { resolve, basename, dirname, join } from 'path';
+import { loadConfig, validateConfig, checkApiKey } from '../config/index.js';
+import { DEFAULT_MODELS } from '../config/types.js';
+import { scanDirectory } from '../scanner/index.js';
+import { createLLMClient } from '../llm/index.js';
+import { generateForElements, groupDocsByFile, writeDocsToDirectory, writeDocsByTopic, writeLlmsTxt } from '../generator/index.js';
+/**
+ * Read .skryptignore patterns from source directory
+ */
+function readIgnorePatterns(sourcePath) {
+    const ignorePath = join(sourcePath, '.skryptignore');
+    if (!existsSync(ignorePath))
+        return [];
+    const content = readFileSync(ignorePath, 'utf-8');
+    return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'));
+}
+/**
+ * Auto-detect OpenAPI spec file in source directory
+ */
+function findOpenAPISpec(sourcePath) {
+    const candidates = [
+        'openapi.json',
+        'openapi.yaml',
+        'openapi.yml',
+        'swagger.json',
+        'swagger.yaml',
+        'swagger.yml',
+        'api.json',
+        'api.yaml',
+        'api.yml',
+    ];
+    for (const name of candidates) {
+        const specPath = join(sourcePath, name);
+        if (existsSync(specPath)) {
+            return specPath;
+        }
+    }
+    // Check common subdirectories
+    const subdirs = ['docs', 'api', 'spec', '.'];
+    for (const subdir of subdirs) {
+        for (const name of candidates) {
+            const specPath = join(sourcePath, subdir, name);
+            if (existsSync(specPath)) {
+                return specPath;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if element should be excluded based on patterns
+ */
+function shouldExcludeElement(element, patterns) {
+    for (const pattern of patterns) {
+        // Match by name
+        if (pattern.startsWith('name:')) {
+            const namePattern = pattern.slice(5);
+            if (element.name === namePattern || element.name.match(new RegExp(namePattern))) {
+                return true;
+            }
+        }
+        // Match by file path
+        else if (pattern.includes('/') || pattern.includes('*')) {
+            const filePath = element.filePath;
+            if (pattern.includes('**')) {
+                const parts = pattern.split('**');
+                const prefixMatch = !parts[0] || filePath.includes(parts[0].replace(/^\//, ''));
+                const suffixMatch = !parts[1] || filePath.includes(parts[1].replace(/^\//, ''));
+                if (prefixMatch && suffixMatch)
+                    return true;
+            }
+            else if (filePath.includes(pattern.replace(/\*/g, ''))) {
+                return true;
+            }
+        }
+        // Match by exact name
+        else if (element.name === pattern) {
+            return true;
+        }
+    }
+    return false;
+}
+export const generateCommand = new Command('generate')
+    .description('Generate documentation with code examples')
+    .argument('<source>', 'Source directory to scan')
+    .option('-o, --output <dir>', 'Output directory')
+    .option('-c, --config <file>', 'Config file path')
+    .option('--provider <name>', 'LLM provider (deepseek, openai, anthropic, google, ollama, openrouter)')
+    .option('--model <name>', 'LLM model name')
+    .option('--base-url <url>', 'Custom API base URL (for Ollama or proxies)')
+    .option('--dry-run', 'Scan only, do not generate docs')
+    .option('--multi-lang', 'Generate TypeScript + Python examples')
+    .option('--by-topic', 'Organize output by topic instead of file')
+    .option('--openapi <file>', 'Include OpenAPI spec file for API Playground')
+    .option('--public-only', 'Only document exported/public APIs')
+    .option('--exclude <patterns...>', 'Exclude patterns (files, names, or name:pattern)')
+    .option('--llms-txt', 'Generate llms.txt for Answer Engine Optimization (AEO)')
+    .option('--project-name <name>', 'Project name for llms.txt header')
+    .action(async (source, options) => {
+    const startTime = Date.now();
+    // Load config (file or defaults)
+    const config = loadConfig(options.config);
+    // CLI flags override config
+    if (source)
+        config.source.path = source;
+    if (options.output)
+        config.output.path = options.output;
+    if (options.provider) {
+        config.llm.provider = options.provider;
+        // Use provider's default model unless explicitly specified
+        if (!options.model) {
+            config.llm.model = DEFAULT_MODELS[config.llm.provider];
+        }
+    }
+    if (options.model)
+        config.llm.model = options.model;
+    if (options.baseUrl)
+        config.llm.baseUrl = options.baseUrl;
+    // Validate
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+        console.error('Config errors:');
+        errors.forEach(e => console.error(`  - ${e}`));
+        process.exit(1);
+    }
+    // Check for API key (not needed for Ollama or dry-run)
+    if (!options.dryRun) {
+        const { ok, envKey } = checkApiKey(config.llm.provider);
+        if (!ok && envKey) {
+            console.error(`Error: ${envKey} environment variable required for ${config.llm.provider}`);
+            process.exit(1);
+        }
+    }
+    console.log('skrypt generate');
+    console.log(`  source:   ${config.source.path}`);
+    console.log(`  output:   ${config.output.path}`);
+    console.log(`  provider: ${config.llm.provider}`);
+    console.log(`  model:    ${config.llm.model}`);
+    if (config.llm.baseUrl) {
+        console.log(`  base url: ${config.llm.baseUrl}`);
+    }
+    console.log('');
+    // Check source exists
+    const sourcePath = resolve(config.source.path);
+    if (!existsSync(sourcePath)) {
+        console.error(`Error: Source directory not found: ${sourcePath}`);
+        process.exit(1);
+    }
+    // Step 1: Scan source code
+    console.log('Step 1: Scanning source code...');
+    const scanResult = await scanDirectory(sourcePath, {
+        include: config.source.include,
+        exclude: config.source.exclude,
+        onProgress: (current, total, file) => {
+            process.stdout.write(`\r  [${current}/${total}] ${file.slice(-50).padStart(50)}`);
+        }
+    });
+    console.log('');
+    if (scanResult.errors.length > 0) {
+        console.log('\n  Scan warnings:');
+        scanResult.errors.slice(0, 5).forEach(e => console.log(`    - ${e}`));
+        if (scanResult.errors.length > 5) {
+            console.log(`    ... and ${scanResult.errors.length - 5} more`);
+        }
+    }
+    console.log(`\n  Found ${scanResult.totalElements} API elements in ${scanResult.files.length} files`);
+    if (scanResult.totalElements === 0) {
+        console.log('  No API elements found. Nothing to generate.');
+        process.exit(0);
+    }
+    // Collect all elements
+    let allElements = [];
+    for (const file of scanResult.files) {
+        for (const el of file.elements) {
+            allElements.push(el);
+        }
+    }
+    // Apply privacy filters
+    const initialCount = allElements.length;
+    // 1. --public-only: filter to exported/public APIs only
+    if (options.publicOnly) {
+        allElements = allElements.filter(el => el.isExported === true || el.isPublic === true);
+        console.log(`  --public-only: filtered to ${allElements.length} exported APIs`);
+    }
+    // 2. Load .skryptignore patterns
+    const ignorePatterns = readIgnorePatterns(sourcePath);
+    if (ignorePatterns.length > 0) {
+        console.log(`  .skryptignore: loaded ${ignorePatterns.length} patterns`);
+    }
+    // 3. Combine with --exclude patterns
+    const excludePatterns = [...ignorePatterns, ...(options.exclude || [])];
+    if (excludePatterns.length > 0) {
+        allElements = allElements.filter(el => !shouldExcludeElement(el, excludePatterns));
+        if (options.exclude?.length) {
+            console.log(`  --exclude: applied ${options.exclude.length} additional patterns`);
+        }
+    }
+    if (initialCount !== allElements.length) {
+        console.log(`  Filtered: ${initialCount} -> ${allElements.length} elements`);
+    }
+    // Show summary by kind
+    const byKind = {};
+    for (const el of allElements) {
+        byKind[el.kind] = (byKind[el.kind] || 0) + 1;
+    }
+    const pluralize = (word, count) => {
+        if (count === 1)
+            return word;
+        if (word === 'class')
+            return 'classes';
+        return word + 's';
+    };
+    console.log('  ' + Object.entries(byKind).map(([k, v]) => `${v} ${pluralize(k, v)}`).join(', '));
+    // Dry run - stop here
+    if (options.dryRun) {
+        console.log('\n[dry run - stopping before generation]');
+        process.exit(0);
+    }
+    // Step 2: Generate docs
+    console.log('\nStep 2: Generating documentation...');
+    const client = createLLMClient({
+        provider: config.llm.provider,
+        model: config.llm.model,
+        baseUrl: config.llm.baseUrl
+    });
+    let lastElement = '';
+    const multiLanguage = options.multiLang ?? false;
+    if (multiLanguage) {
+        console.log('  mode: multi-language (TypeScript + Python)');
+    }
+    const docs = await generateForElements(allElements, client, {
+        multiLanguage,
+        onProgress: (progress) => {
+            if (progress.element !== lastElement) {
+                if (lastElement)
+                    console.log('');
+                lastElement = progress.element;
+            }
+            process.stdout.write(`\r  [${progress.current}/${progress.total}] ${progress.element}: ${progress.status}`.padEnd(80));
+        }
+    });
+    console.log('\n');
+    // Step 3: Write output
+    console.log('Step 3: Writing documentation...');
+    const outputPath = resolve(config.output.path);
+    let filesWritten;
+    let totalDocs;
+    if (options.byTopic) {
+        console.log('  mode: by-topic (grouped by concept)');
+        const result = await writeDocsByTopic(docs, outputPath);
+        filesWritten = result.filesWritten;
+        totalDocs = result.totalDocs;
+        console.log(`  topics: ${result.topics.map(t => t.name).join(', ')}`);
+    }
+    else {
+        // Default: file-based output
+        const fileResults = groupDocsByFile(docs);
+        const result = await writeDocsToDirectory(fileResults, outputPath, sourcePath);
+        filesWritten = result.filesWritten;
+        totalDocs = result.totalDocs;
+    }
+    const errorCount = docs.filter(d => d.error).length;
+    const duration = Math.round((Date.now() - startTime) / 1000);
+    console.log(`\n  Wrote ${filesWritten} documentation files to ${outputPath}`);
+    // Copy OpenAPI spec (provided or auto-detected)
+    let specPath = options.openapi ? resolve(options.openapi) : null;
+    // Auto-detect if not provided
+    if (!specPath) {
+        const detected = findOpenAPISpec(sourcePath);
+        if (detected) {
+            specPath = detected;
+            console.log(`\n  Auto-detected OpenAPI spec: ${basename(detected)}`);
+        }
+    }
+    if (specPath) {
+        if (existsSync(specPath)) {
+            const specFilename = basename(specPath);
+            const contentDir = dirname(outputPath);
+            const destPath = resolve(contentDir, specFilename);
+            mkdirSync(dirname(destPath), { recursive: true });
+            copyFileSync(specPath, destPath);
+            console.log(`  Copied OpenAPI spec: ${specFilename} -> ${destPath}`);
+            console.log('  API Playground will be available at /reference');
+        }
+        else if (options.openapi) {
+            console.log(`\n  Warning: OpenAPI spec not found: ${specPath}`);
+        }
+    }
+    // Generate llms.txt for AEO (Answer Engine Optimization)
+    if (options.llmsTxt) {
+        await writeLlmsTxt(docs, outputPath, {
+            projectName: options.projectName,
+            description: `API documentation for ${options.projectName || basename(sourcePath)}`
+        });
+        console.log(`\n  Generated llms.txt and llms-full.md for AEO`);
+    }
+    console.log('\n=== Summary ===');
+    console.log(`  Total elements: ${totalDocs}`);
+    console.log(`  Generated:      ${totalDocs - errorCount}`);
+    if (errorCount > 0) {
+        console.log(`  Errors:         ${errorCount}`);
+    }
+    console.log(`  Duration:       ${duration}s`);
+    console.log(`  Output:         ${outputPath}`);
+    if (errorCount > 0) {
+        console.log('\n  Elements with errors:');
+        docs.filter(d => d.error).slice(0, 10).forEach(d => {
+            console.log(`    - ${d.element.name}: ${d.error?.slice(0, 50)}`);
+        });
+        if (errorCount > 10) {
+            console.log(`    ... and ${errorCount - 10} more`);
+        }
+    }
+    console.log('\nDone!');
+});

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import { existsSync, mkdirSync, cpSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const initCommand = new Command('init')
+    .description('Initialize a new documentation site')
+    .argument('[directory]', 'Target directory', '.')
+    .option('--name <name>', 'Project name', 'my-docs')
+    .action(async (directory, options) => {
+    const targetDir = join(process.cwd(), directory);
+    console.log('skrypt init');
+    console.log(`  directory: ${targetDir}`);
+    console.log(`  name:      ${options.name}`);
+    console.log('');
+    // Check if directory exists and is not empty
+    if (existsSync(targetDir)) {
+        const files = readdirSync(targetDir);
+        if (files.length > 0 && !files.every((f) => f.startsWith('.'))) {
+            console.error('Error: Target directory is not empty');
+            process.exit(1);
+        }
+    }
+    // Create target directory
+    mkdirSync(targetDir, { recursive: true });
+    // Copy template
+    const templateDir = join(__dirname, '..', '..', 'template');
+    if (!existsSync(templateDir)) {
+        console.error('Error: Template not found. Please reinstall skrypt.');
+        process.exit(1);
+    }
+    console.log('Creating documentation site...');
+    cpSync(templateDir, targetDir, { recursive: true });
+    // Update package.json with project name
+    const packageJsonPath = join(targetDir, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    packageJson.name = options.name;
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    // Update docs.json with project name
+    const docsJsonPath = join(targetDir, 'docs.json');
+    const docsJson = JSON.parse(readFileSync(docsJsonPath, 'utf-8'));
+    docsJson.name = options.name;
+    writeFileSync(docsJsonPath, JSON.stringify(docsJson, null, 2));
+    console.log('');
+    console.log('Done! Next steps:');
+    console.log('');
+    console.log(`  cd ${directory === '.' ? '.' : directory}`);
+    console.log('  npm install');
+    console.log('  npm run dev');
+    console.log('');
+    console.log('Then open http://localhost:3000 to see your docs.');
+    console.log('');
+    console.log('To generate API documentation:');
+    console.log('  skrypt generate ./src -o ./content/docs');
+});

package/dist/commands/review-pr.d.ts

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

package/dist/commands/review-pr.js

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import { analyzePRForDocs, postPRComment, postInlineComments } from '../github/pr-comments.js';
+export const reviewPRCommand = new Command('review-pr')
+    .description('Review a GitHub PR for documentation issues')
+    .argument('<pr-url>', 'GitHub PR URL (e.g., https://github.com/owner/repo/pull/123)')
+    .option('--inline', 'Post inline comments instead of a single comment')
+    .option('--dry-run', 'Show issues without posting comments')
+    .option('--token <token>', 'GitHub token (or use GITHUB_TOKEN env var)')
+    .action(async (prUrl, options) => {
+    // Parse PR URL
+    const urlMatch = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+    if (!urlMatch) {
+        console.error('Error: Invalid PR URL format');
+        console.error('Expected: https://github.com/owner/repo/pull/123');
+        process.exit(1);
+    }
+    const owner = urlMatch[1];
+    const repo = urlMatch[2];
+    const pullNumber = urlMatch[3];
+    if (!owner || !repo || !pullNumber) {
+        console.error('Error: Could not parse owner/repo/PR number from URL');
+        process.exit(1);
+    }
+    console.log('skrypt review-pr');
+    console.log(`  repo:   ${owner}/${repo}`);
+    console.log(`  PR:     #${pullNumber}`);
+    console.log('');
+    const token = options.token || process.env.GITHUB_TOKEN;
+    if (!token) {
+        console.error('Error: GITHUB_TOKEN environment variable or --token required');
+        process.exit(1);
+    }
+    // Analyze the PR
+    console.log('Analyzing PR for documentation issues...');
+    const config = {
+        owner,
+        repo,
+        pullNumber: parseInt(pullNumber),
+        token,
+    };
+    let issues;
+    try {
+        issues = await analyzePRForDocs(config);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error analyzing PR: ${message}`);
+        process.exit(1);
+    }
+    if (issues.length === 0) {
+        console.log('\n✓ No documentation issues found!');
+        process.exit(0);
+    }
+    console.log(`\nFound ${issues.length} issue(s):`);
+    console.log('');
+    // Group by severity
+    const errors = issues.filter(i => i.severity === 'error');
+    const warnings = issues.filter(i => i.severity === 'warning');
+    const infos = issues.filter(i => i.severity === 'info');
+    if (errors.length > 0) {
+        console.log(`❌ Errors (${errors.length}):`);
+        for (const issue of errors) {
+            console.log(`   ${issue.file}: ${issue.message}`);
+        }
+    }
+    if (warnings.length > 0) {
+        console.log(`⚠️  Warnings (${warnings.length}):`);
+        for (const issue of warnings) {
+            console.log(`   ${issue.file}: ${issue.message}`);
+        }
+    }
+    if (infos.length > 0) {
+        console.log(`ℹ️  Suggestions (${infos.length}):`);
+        for (const issue of infos) {
+            console.log(`   ${issue.file}: ${issue.message}`);
+        }
+    }
+    if (options.dryRun) {
+        console.log('\n[dry run - no comments posted]');
+        process.exit(0);
+    }
+    // Post comments
+    console.log('\nPosting comments to PR...');
+    if (options.inline) {
+        const inlineIssues = issues.filter(i => i.line);
+        const generalIssues = issues.filter(i => !i.line);
+        if (inlineIssues.length > 0) {
+            const inlineResults = await postInlineComments(config, inlineIssues);
+            const success = inlineResults.filter(r => r.success).length;
+            console.log(`  Posted ${success}/${inlineIssues.length} inline comments`);
+        }
+        if (generalIssues.length > 0) {
+            const result = await postPRComment(config, generalIssues);
+            if (result.success) {
+                console.log(`  Posted summary comment`);
+            }
+            else {
+                console.error(`  Failed to post summary: ${result.error}`);
+            }
+        }
+    }
+    else {
+        const result = await postPRComment(config, issues);
+        if (result.success) {
+            console.log(`✓ Comment posted successfully`);
+        }
+        else {
+            console.error(`✗ Failed to post comment: ${result.error}`);
+            process.exit(1);
+        }
+    }
+    console.log('\nDone!');
+    // Exit with error code if there are errors
+    if (errors.length > 0) {
+        process.exit(1);
+    }
+});

package/dist/commands/watch.d.ts

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

package/dist/commands/watch.js

@@ -0,0 +1,142 @@
+import { Command } from 'commander';
+import { watch } from 'chokidar';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { loadConfig, validateConfig, checkApiKey } from '../config/index.js';
+import { DEFAULT_MODELS } from '../config/types.js';
+import { scanDirectory } from '../scanner/index.js';
+import { createLLMClient } from '../llm/index.js';
+import { generateForElements, groupDocsByFile, writeDocsToDirectory } from '../generator/index.js';
+export const watchCommand = new Command('watch')
+    .description('Watch source files and regenerate docs on changes')
+    .argument('<source>', 'Source directory to watch')
+    .option('-o, --output <dir>', 'Output directory')
+    .option('-c, --config <file>', 'Config file path')
+    .option('--provider <name>', 'LLM provider')
+    .option('--model <name>', 'LLM model name')
+    .option('--debounce <ms>', 'Debounce time in milliseconds', '1000')
+    .action(async (source, options) => {
+    const config = loadConfig(options.config);
+    if (source)
+        config.source.path = source;
+    if (options.output)
+        config.output.path = options.output;
+    if (options.provider) {
+        config.llm.provider = options.provider;
+        if (!options.model) {
+            config.llm.model = DEFAULT_MODELS[config.llm.provider];
+        }
+    }
+    if (options.model)
+        config.llm.model = options.model;
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+        console.error('Config errors:', errors);
+        process.exit(1);
+    }
+    const { ok, envKey } = checkApiKey(config.llm.provider);
+    if (!ok && envKey) {
+        console.error(`Error: ${envKey} required`);
+        process.exit(1);
+    }
+    const sourcePath = resolve(config.source.path);
+    const outputPath = resolve(config.output.path);
+    if (!existsSync(sourcePath)) {
+        console.error(`Source not found: ${sourcePath}`);
+        process.exit(1);
+    }
+    console.log('skrypt watch');
+    console.log(`  source: ${sourcePath}`);
+    console.log(`  output: ${outputPath}`);
+    console.log(`  provider: ${config.llm.provider}`);
+    console.log('');
+    const client = createLLMClient({
+        provider: config.llm.provider,
+        model: config.llm.model,
+        baseUrl: config.llm.baseUrl
+    });
+    let generating = false;
+    let pendingGenerate = false;
+    const debounceMs = parseInt(options.debounce);
+    async function generate() {
+        if (generating) {
+            pendingGenerate = true;
+            return;
+        }
+        generating = true;
+        const startTime = Date.now();
+        try {
+            console.log('\n[' + new Date().toLocaleTimeString() + '] Regenerating docs...');
+            const scanResult = await scanDirectory(sourcePath, {
+                include: config.source.include,
+                exclude: config.source.exclude,
+            });
+            if (scanResult.totalElements === 0) {
+                console.log('  No elements found');
+                return;
+            }
+            const allElements = [];
+            for (const file of scanResult.files) {
+                allElements.push(...file.elements);
+            }
+            const docs = await generateForElements(allElements, client, {
+                onProgress: (p) => {
+                    process.stdout.write(`\r  [${p.current}/${p.total}] ${p.element}`.padEnd(60));
+                }
+            });
+            const fileResults = groupDocsByFile(docs);
+            await writeDocsToDirectory(fileResults, outputPath, sourcePath);
+            const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+            console.log(`\n  Done in ${duration}s`);
+        }
+        catch (err) {
+            console.error('\n  Error:', err);
+        }
+        finally {
+            generating = false;
+            if (pendingGenerate) {
+                pendingGenerate = false;
+                setTimeout(generate, debounceMs);
+            }
+        }
+    }
+    // Initial generation
+    await generate();
+    // Watch for changes
+    console.log('\nWatching for changes... (Ctrl+C to stop)');
+    let debounceTimer = null;
+    const watcher = watch(sourcePath, {
+        ignored: [
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/dist/**',
+            '**/__pycache__/**',
+        ],
+        persistent: true,
+        ignoreInitial: true,
+    });
+    watcher.on('change', (path) => {
+        console.log(`  Changed: ${path}`);
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(generate, debounceMs);
+    });
+    watcher.on('add', (path) => {
+        console.log(`  Added: ${path}`);
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(generate, debounceMs);
+    });
+    watcher.on('unlink', (path) => {
+        console.log(`  Removed: ${path}`);
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(generate, debounceMs);
+    });
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('\nStopping watch...');
+        watcher.close();
+        process.exit(0);
+    });
+});

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './loader.js';

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './loader.js';

package/dist/config/loader.d.ts

@@ -0,0 +1,9 @@
+import { Config, LLMProvider } from './types.js';
+export declare function findConfigFile(dir: string): string | null;
+export declare function loadConfig(configPath?: string): Config;
+export declare function validateConfig(config: Config): string[];
+export declare function getRequiredEnvKey(provider: LLMProvider): string | null;
+export declare function checkApiKey(provider: LLMProvider): {
+    ok: boolean;
+    envKey: string | null;
+};