skrypt-ai 0.1.3 → 0.1.4

package/dist/cli.js

@@ -5,7 +5,7 @@ import { initCommand } from './commands/init.js';
 import { watchCommand } from './commands/watch.js';
 import { autofixCommand } from './commands/autofix.js';
 import { reviewPRCommand } from './commands/review-pr.js';
-const VERSION = '0.1.3';
+const VERSION = '0.1.4';
 async function checkForUpdates() {
     try {
         const res = await fetch('https://registry.npmjs.org/skrypt-ai/latest', {

package/dist/config/loader.d.ts

@@ -2,7 +2,6 @@ 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;

package/dist/config/loader.js

@@ -69,9 +69,6 @@ export function validateConfig(config) {
     }
     return errors;
 }
-export function getRequiredEnvKey(provider) {
-    return PROVIDER_ENV_KEYS[provider] || null;
-}
 export function checkApiKey(provider) {
     const envKey = PROVIDER_ENV_KEYS[provider];
     // Ollama doesn't need an API key

package/dist/generator/organizer.js

@@ -45,7 +45,9 @@ export function organizeByTopic(docs, config = DEFAULT_TOPIC_CONFIG) {
         if (!topicDocs.has(topicId)) {
             topicDocs.set(topicId, []);
         }
-        topicDocs.get(topicId).push(doc);
+        const topicDocList = topicDocs.get(topicId);
+        if (topicDocList)
+            topicDocList.push(doc);
     }
     // Build topic objects
     const topics = [];

package/dist/generator/writer.js

@@ -18,7 +18,9 @@ export async function writeLlmsTxt(docs, outputDir, options = {}) {
         if (!byFile.has(file)) {
             byFile.set(file, []);
         }
-        byFile.get(file).push(doc);
+        const fileDocs = byFile.get(file);
+        if (fileDocs)
+            fileDocs.push(doc);
     }
     // Summary section
     content += `## Overview\n\n`;
@@ -133,7 +135,9 @@ export function groupDocsByFile(docs) {
         if (!byFile.has(file)) {
             byFile.set(file, []);
         }
-        byFile.get(file).push(doc);
+        const fileDocs = byFile.get(file);
+        if (fileDocs)
+            fileDocs.push(doc);
     }
     return Array.from(byFile.entries()).map(([filePath, fileDocs]) => ({
         filePath,

package/dist/scanner/index.d.ts

@@ -12,7 +12,7 @@ export interface ScanAllResult {
     errors: string[];
 }
 /**
- * Scan a directory for all API elements
+ * Scan a directory (or single file) for all API elements
  */
 export declare function scanDirectory(dir: string, options?: ScanOptions): Promise<ScanAllResult>;
 /**

package/dist/scanner/index.js

@@ -1,4 +1,4 @@
-import { readdir } from 'fs/promises';
+import { readdir, stat } from 'fs/promises';
 import { join, extname } from 'path';
 import { PythonScanner } from './python.js';
 import { TypeScriptScanner } from './typescript.js';
@@ -89,12 +89,21 @@ async function findFiles(dir, include, exclude) {
     return files;
 }
 /**
- * Scan a directory for all API elements
+ * Scan a directory (or single file) for all API elements
  */
 export async function scanDirectory(dir, options = {}) {
     const include = options.include || ['**/*.py', '**/*.ts', '**/*.js', '**/*.go', '**/*.rs'];
     const exclude = options.exclude || ['**/node_modules/**', '**/__pycache__/**', '**/dist/**'];
-    const files = await findFiles(dir, include, exclude);
+    // Check if input is a file or directory
+    const stats = await stat(dir);
+    let files;
+    if (stats.isFile()) {
+        // Single file - just use it if it has a scanner
+        files = getScannerForFile(dir) ? [dir] : [];
+    }
+    else {
+        files = await findFiles(dir, include, exclude);
+    }
     const results = [];
     const allErrors = [];
     let totalElements = 0;

package/dist/scanner/integration.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Integration tests for the full scanning pipeline
+ */
+export {};

package/dist/scanner/integration.test.js

@@ -0,0 +1,181 @@
+/**
+ * Integration tests for the full scanning pipeline
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { writeFileSync, mkdirSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { scanDirectory, scanFile } from './index.js';
+const TEST_DIR = join(process.cwd(), 'test-fixtures');
+describe('Scanner Integration', () => {
+    beforeAll(() => {
+        // Create test fixtures
+        mkdirSync(TEST_DIR, { recursive: true });
+        // TypeScript file
+        writeFileSync(join(TEST_DIR, 'sample.ts'), `
+/**
+ * Add two numbers
+ * @param a First number
+ * @param b Second number
+ */
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export class Calculator {
+  value: number = 0;
+
+  add(n: number): this {
+    this.value += n;
+    return this;
+  }
+}
+`);
+        // Python file
+        writeFileSync(join(TEST_DIR, 'utils.py'), `
+"""Utility functions."""
+
+def greet(name: str) -> str:
+    """Greet someone by name."""
+    return f"Hello, {name}!"
+
+class Helper:
+    """Helper class."""
+
+    def process(self, data: dict) -> dict:
+        """Process data."""
+        return data
+`);
+        // Go file
+        writeFileSync(join(TEST_DIR, 'handlers.go'), `
+package handlers
+
+// GetUser retrieves a user
+func GetUser(id string) string {
+    return id
+}
+
+type Service struct {
+    name string
+}
+`);
+        // Rust file
+        writeFileSync(join(TEST_DIR, 'lib.rs'), `
+/// Configuration struct
+pub struct Config {
+    pub name: String,
+}
+
+impl Config {
+    /// Create new config
+    pub fn new() -> Self {
+        Config { name: String::new() }
+    }
+}
+
+/// Parse config from string
+pub fn parse_config(s: &str) -> Config {
+    Config { name: s.to_string() }
+}
+`);
+    });
+    afterAll(() => {
+        // Cleanup test fixtures
+        if (existsSync(TEST_DIR)) {
+            rmSync(TEST_DIR, { recursive: true });
+        }
+    });
+    describe('scanDirectory', () => {
+        it('scans all supported languages', async () => {
+            const result = await scanDirectory(TEST_DIR);
+            expect(result.errors).toHaveLength(0);
+            expect(result.files.length).toBeGreaterThanOrEqual(4);
+            expect(result.totalElements).toBeGreaterThanOrEqual(8);
+            // Check we found elements from each language
+            const allElements = result.files.flatMap(f => f.elements);
+            const languages = new Set(result.files.map(f => f.language));
+            expect(languages.has('typescript')).toBe(true);
+            expect(languages.has('python')).toBe(true);
+            expect(languages.has('go')).toBe(true);
+            expect(languages.has('rust')).toBe(true);
+        });
+        it('respects exclude patterns', async () => {
+            const result = await scanDirectory(TEST_DIR, {
+                exclude: ['**/utils.py']
+            });
+            // Should not find the utils.py file
+            const fileNames = result.files.map(f => f.filePath);
+            const hasPython = fileNames.some(f => f.includes('utils.py'));
+            expect(hasPython).toBe(false);
+        });
+        it('respects include patterns', async () => {
+            const result = await scanDirectory(TEST_DIR, {
+                include: ['**/*.ts']
+            });
+            expect(result.files.length).toBe(1);
+            expect(result.files[0].language).toBe('typescript');
+        });
+        it('calls progress callback', async () => {
+            const progress = [];
+            await scanDirectory(TEST_DIR, {
+                onProgress: (current, total) => {
+                    progress.push({ current, total });
+                }
+            });
+            expect(progress.length).toBeGreaterThan(0);
+            expect(progress[0].current).toBe(1);
+        });
+    });
+    describe('scanFile', () => {
+        it('scans a single TypeScript file', async () => {
+            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
+            expect(result.errors).toHaveLength(0);
+            expect(result.language).toBe('typescript');
+            expect(result.elements.length).toBeGreaterThanOrEqual(2);
+            const functionNames = result.elements.map(e => e.name);
+            expect(functionNames).toContain('add');
+            expect(functionNames).toContain('Calculator');
+        });
+        it('scans a single Python file', async () => {
+            const result = await scanFile(join(TEST_DIR, 'utils.py'));
+            expect(result.errors).toHaveLength(0);
+            expect(result.language).toBe('python');
+            const names = result.elements.map(e => e.name);
+            expect(names).toContain('greet');
+            expect(names).toContain('Helper');
+        });
+        it('returns error for unsupported file type', async () => {
+            const result = await scanFile(join(TEST_DIR, 'unknown.xyz'));
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.elements).toHaveLength(0);
+        });
+    });
+    describe('single file via scanDirectory', () => {
+        it('accepts a single file path', async () => {
+            const result = await scanDirectory(join(TEST_DIR, 'sample.ts'));
+            expect(result.errors).toHaveLength(0);
+            expect(result.files.length).toBe(1);
+            expect(result.files[0].language).toBe('typescript');
+        });
+    });
+    describe('element extraction', () => {
+        it('extracts function parameters', async () => {
+            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
+            const addFn = result.elements.find(e => e.name === 'add');
+            expect(addFn).toBeDefined();
+            expect(addFn?.parameters).toHaveLength(2);
+            expect(addFn?.parameters[0].name).toBe('a');
+            expect(addFn?.parameters[0].type).toBe('number');
+        });
+        it('extracts docstrings', async () => {
+            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
+            const addFn = result.elements.find(e => e.name === 'add');
+            expect(addFn?.docstring).toContain('Add two numbers');
+        });
+        it('extracts class methods', async () => {
+            const result = await scanFile(join(TEST_DIR, 'sample.ts'));
+            const addMethod = result.elements.find(e => e.name === 'add' && e.kind === 'method');
+            expect(addMethod).toBeDefined();
+            expect(addMethod?.parentClass).toBe('Calculator');
+        });
+    });
+});

package/package.json

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