skrypt-ai 0.1.0

package/dist/scanner/scanner.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import { scanFile, scanDirectory } from './index.js';
+import { join } from 'path';
+const TESTDATA = join(process.cwd(), 'testdata');
+describe('Scanner', () => {
+    describe('scanFile', () => {
+        describe('Python files', () => {
+            it('should scan Python file and extract elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                expect(result.errors).toHaveLength(0);
+                expect(result.language).toBe('python');
+                expect(result.elements.length).toBeGreaterThan(0);
+            });
+            it('should find expected Python functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('greet');
+                expect(names).toContain('fetch_data');
+            });
+            it('should find Python class and methods', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Calculator');
+                expect(names).toContain('add');
+                expect(names).toContain('multiply');
+            });
+            it('should exclude private Python elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const names = result.elements.map(e => e.name);
+                expect(names).not.toContain('_private_method');
+                expect(names).not.toContain('_private_function');
+                expect(names).not.toContain('_PrivateClass');
+            });
+            it('should detect async Python functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const fetchData = result.elements.find(e => e.name === 'fetch_data');
+                expect(fetchData).toBeDefined();
+                expect(fetchData?.isAsync).toBe(true);
+            });
+            it('should extract Python function parameters', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const greet = result.elements.find(e => e.name === 'greet');
+                expect(greet).toBeDefined();
+                expect(greet?.parameters).toHaveLength(2);
+                expect(greet?.parameters[0].name).toBe('name');
+                expect(greet?.parameters[0].type).toBe('str');
+            });
+            it('should extract Python docstrings', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.py'));
+                const greet = result.elements.find(e => e.name === 'greet');
+                expect(greet?.docstring).toContain('Generate a greeting');
+            });
+        });
+        describe('TypeScript files', () => {
+            it('should scan TypeScript file and extract elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                expect(result.errors).toHaveLength(0);
+                expect(result.language).toBe('typescript');
+                expect(result.elements.length).toBeGreaterThan(0);
+            });
+            it('should find expected TypeScript functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('greet');
+                expect(names).toContain('fetchData');
+                expect(names).toContain('processItems');
+            });
+            it('should find TypeScript class and methods', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Calculator');
+                expect(names).toContain('add');
+                expect(names).toContain('multiply');
+            });
+            it('should exclude non-exported TypeScript elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                const names = result.elements.map(e => e.name);
+                expect(names).not.toContain('internalHelper');
+                expect(names).not.toContain('_privateFunction');
+            });
+            it('should detect async TypeScript functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                const fetchData = result.elements.find(e => e.name === 'fetchData');
+                const processItems = result.elements.find(e => e.name === 'processItems');
+                expect(fetchData?.isAsync).toBe(true);
+                expect(processItems?.isAsync).toBe(true);
+            });
+            it('should set parentClass for methods', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.ts'));
+                const addMethod = result.elements.find(e => e.name === 'add');
+                expect(addMethod?.parentClass).toBe('Calculator');
+                expect(addMethod?.kind).toBe('method');
+            });
+        });
+        describe('Go files', () => {
+            it('should scan Go file and extract elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                expect(result.errors).toHaveLength(0);
+                expect(result.language).toBe('go');
+                expect(result.elements.length).toBeGreaterThan(0);
+            });
+            it('should find exported Go functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Greet');
+                expect(names).toContain('FetchData');
+                expect(names).toContain('NewCalculator');
+                expect(names).toContain('ProcessItems');
+            });
+            it('should find Go types', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Config');
+                expect(names).toContain('Calculator');
+                expect(names).toContain('Client');
+            });
+            it('should find Go methods', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Add');
+                expect(names).toContain('Multiply');
+            });
+            it('should exclude non-exported Go functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                const names = result.elements.map(e => e.name);
+                expect(names).not.toContain('privateFunction');
+                expect(names).not.toContain('privateMethod');
+            });
+            it('should extract Go doc comments', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.go'));
+                const greet = result.elements.find(e => e.name === 'Greet');
+                expect(greet?.docstring).toContain('generates a greeting');
+            });
+        });
+        describe('Rust files', () => {
+            it('should scan Rust file and extract elements', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                expect(result.errors).toHaveLength(0);
+                expect(result.language).toBe('rust');
+                expect(result.elements.length).toBeGreaterThan(0);
+            });
+            it('should find pub Rust functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('greet');
+                expect(names).toContain('fetch_data');
+                expect(names).toContain('process_items');
+            });
+            it('should find pub Rust types', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('Config');
+                expect(names).toContain('Calculator');
+                expect(names).toContain('Client');
+            });
+            it('should find pub impl methods', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const names = result.elements.map(e => e.name);
+                expect(names).toContain('new');
+                expect(names).toContain('add');
+                expect(names).toContain('multiply');
+            });
+            it('should exclude non-pub Rust functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const names = result.elements.map(e => e.name);
+                expect(names).not.toContain('private_function');
+                expect(names).not.toContain('private_method');
+            });
+            it('should detect async Rust functions', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const fetchData = result.elements.find(e => e.name === 'fetch_data');
+                expect(fetchData?.isAsync).toBe(true);
+            });
+            it('should extract Rust doc comments', async () => {
+                const result = await scanFile(join(TESTDATA, 'sample.rs'));
+                const greet = result.elements.find(e => e.name === 'greet');
+                expect(greet?.docstring).toContain('Generate a greeting');
+            });
+        });
+    });
+    describe('scanDirectory', () => {
+        it('should scan multiple files in directory', async () => {
+            const result = await scanDirectory(TESTDATA, {
+                include: ['**/*.py', '**/*.ts', '**/*.go', '**/*.rs'],
+                exclude: [],
+            });
+            expect(result.files.length).toBeGreaterThanOrEqual(4);
+            expect(result.totalElements).toBeGreaterThan(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should respect include patterns', async () => {
+            const result = await scanDirectory(TESTDATA, {
+                include: ['**/*.py'],
+                exclude: [],
+            });
+            expect(result.files.every(f => f.language === 'python')).toBe(true);
+        });
+        it('should have files from all languages', async () => {
+            const result = await scanDirectory(TESTDATA, {
+                include: ['**/*.py', '**/*.ts', '**/*.go', '**/*.rs'],
+                exclude: [],
+            });
+            const languages = new Set(result.files.map(f => f.language));
+            expect(languages.has('python')).toBe(true);
+            expect(languages.has('typescript')).toBe(true);
+            expect(languages.has('go')).toBe(true);
+            expect(languages.has('rust')).toBe(true);
+        });
+    });
+});

package/dist/scanner/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Represents a parameter in a function/method signature
+ */
+export interface Parameter {
+    name: string;
+    type?: string;
+    default?: string;
+    description?: string;
+}
+/**
+ * Represents an extracted API element (function, class, method)
+ */
+export interface APIElement {
+    kind: 'function' | 'class' | 'method';
+    name: string;
+    signature: string;
+    parameters: Parameter[];
+    returnType?: string;
+    docstring?: string;
+    filePath: string;
+    lineNumber: number;
+    parentClass?: string;
+    isAsync?: boolean;
+    isExported?: boolean;
+    isPublic?: boolean;
+    imports?: string[];
+    sourceContext?: string;
+    packageName?: string;
+    relatedTypes?: string[];
+}
+/**
+ * Result of scanning a file
+ */
+export interface ScanResult {
+    filePath: string;
+    language: 'python' | 'javascript' | 'typescript' | 'go' | 'rust';
+    elements: APIElement[];
+    errors: string[];
+}
+/**
+ * Scanner interface - each language implements this
+ */
+export interface Scanner {
+    /** Languages this scanner supports */
+    languages: string[];
+    /** Scan a single file and extract API elements */
+    scanFile(filePath: string): Promise<ScanResult>;
+    /** Check if this scanner can handle the given file */
+    canHandle(filePath: string): boolean;
+}

package/dist/scanner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scanner/typescript.d.ts

@@ -0,0 +1,34 @@
+import { Scanner, ScanResult } from './types.js';
+export declare class TypeScriptScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    /**
+     * Extract all import statements from the file
+     */
+    private extractImports;
+    /**
+     * Infer package name from file path
+     */
+    private inferPackageName;
+    /**
+     * Get source context around a node (few lines before/after)
+     */
+    private getSourceContext;
+    private visit;
+    private isPrivate;
+    private isPrivateMember;
+    private isExported;
+    private getPropertyName;
+    private extractFunction;
+    private extractArrowFunction;
+    private extractClass;
+    private extractMethod;
+    private extractConstructor;
+    private extractParameters;
+    private buildSignature;
+    private buildArrowSignature;
+    private buildMethodSignature;
+    private buildConstructorSignature;
+    private getJSDoc;
+}

package/dist/scanner/typescript.js

@@ -0,0 +1,327 @@
+import ts from 'typescript';
+import { readFileSync } from 'fs';
+export class TypeScriptScanner {
+    languages = ['typescript', 'javascript'];
+    canHandle(filePath) {
+        return /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filePath) && !filePath.includes('.d.ts');
+    }
+    async scanFile(filePath) {
+        const language = filePath.endsWith('.ts') || filePath.endsWith('.tsx')
+            ? 'typescript'
+            : 'javascript';
+        try {
+            const source = readFileSync(filePath, 'utf-8');
+            const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') || filePath.endsWith('.jsx')
+                ? ts.ScriptKind.TSX
+                : ts.ScriptKind.TS);
+            const elements = [];
+            const errors = [];
+            // Extract imports for context
+            const imports = this.extractImports(sourceFile);
+            const packageName = this.inferPackageName(filePath);
+            this.visit(sourceFile, sourceFile, elements, filePath, source, imports, packageName);
+            return {
+                filePath,
+                language,
+                elements,
+                errors
+            };
+        }
+        catch (err) {
+            return {
+                filePath,
+                language,
+                elements: [],
+                errors: [`Failed to parse: ${err}`]
+            };
+        }
+    }
+    /**
+     * Extract all import statements from the file
+     */
+    extractImports(sourceFile) {
+        const imports = [];
+        ts.forEachChild(sourceFile, node => {
+            if (ts.isImportDeclaration(node)) {
+                imports.push(node.getText(sourceFile));
+            }
+        });
+        return imports;
+    }
+    /**
+     * Infer package name from file path
+     */
+    inferPackageName(filePath) {
+        // Try to find package.json and extract name
+        const parts = filePath.split('/');
+        for (let i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] === 'src' && i > 0) {
+                // Likely package name is parent of src
+                return parts[i - 1];
+            }
+            if (parts[i] === 'packages' && i < parts.length - 1) {
+                return parts[i + 1];
+            }
+        }
+        // Fallback: use directory name
+        const srcIndex = filePath.lastIndexOf('/src/');
+        if (srcIndex > 0) {
+            const beforeSrc = filePath.slice(0, srcIndex);
+            return beforeSrc.split('/').pop() || 'unknown';
+        }
+        return 'unknown';
+    }
+    /**
+     * Get source context around a node (few lines before/after)
+     */
+    getSourceContext(source, lineNumber, contextLines = 3) {
+        const lines = source.split('\n');
+        const start = Math.max(0, lineNumber - contextLines - 1);
+        const end = Math.min(lines.length, lineNumber + contextLines);
+        return lines.slice(start, end).join('\n');
+    }
+    visit(node, sourceFile, elements, filePath, source, imports, packageName, parentClass) {
+        // Function declarations
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            if (!this.isPrivate(name) && this.isExported(node)) {
+                const element = this.extractFunction(node, sourceFile, filePath);
+                element.imports = imports;
+                element.packageName = packageName;
+                element.sourceContext = this.getSourceContext(source, element.lineNumber, 5);
+                elements.push(element);
+            }
+        }
+        // Arrow functions assigned to const (exported)
+        if (ts.isVariableStatement(node) && this.isExported(node)) {
+            for (const decl of node.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.initializer) {
+                    if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+                        const name = decl.name.text;
+                        if (!this.isPrivate(name)) {
+                            const element = this.extractArrowFunction(decl, decl.initializer, sourceFile, filePath);
+                            element.imports = imports;
+                            element.packageName = packageName;
+                            element.sourceContext = this.getSourceContext(source, element.lineNumber, 5);
+                            elements.push(element);
+                        }
+                    }
+                }
+            }
+        }
+        // Class declarations
+        if (ts.isClassDeclaration(node) && node.name) {
+            const name = node.name.text;
+            if (!this.isPrivate(name) && this.isExported(node)) {
+                const classElement = this.extractClass(node, sourceFile, filePath);
+                classElement.imports = imports;
+                classElement.packageName = packageName;
+                classElement.sourceContext = this.getSourceContext(source, classElement.lineNumber, 10);
+                elements.push(classElement);
+                // Extract methods
+                for (const member of node.members) {
+                    if (ts.isMethodDeclaration(member) && member.name) {
+                        const methodName = this.getPropertyName(member.name);
+                        if (methodName && !this.isPrivateMember(member) && !methodName.startsWith('_')) {
+                            const methodElement = this.extractMethod(member, sourceFile, filePath, name);
+                            methodElement.imports = imports;
+                            methodElement.packageName = packageName;
+                            methodElement.sourceContext = this.getSourceContext(source, methodElement.lineNumber, 5);
+                            elements.push(methodElement);
+                        }
+                    }
+                    if (ts.isConstructorDeclaration(member)) {
+                        const ctorElement = this.extractConstructor(member, sourceFile, filePath, name);
+                        ctorElement.imports = imports;
+                        ctorElement.packageName = packageName;
+                        ctorElement.sourceContext = this.getSourceContext(source, ctorElement.lineNumber, 5);
+                        elements.push(ctorElement);
+                    }
+                }
+            }
+        }
+        // Recurse into children (but not into function/class bodies for top-level scan)
+        if (ts.isSourceFile(node) || ts.isModuleBlock(node)) {
+            ts.forEachChild(node, child => this.visit(child, sourceFile, elements, filePath, source, imports, packageName, parentClass));
+        }
+    }
+    isPrivate(name) {
+        return name.startsWith('_') && !name.startsWith('__');
+    }
+    isPrivateMember(node) {
+        const modifiers = ts.getModifiers(node);
+        if (modifiers) {
+            for (const mod of modifiers) {
+                if (mod.kind === ts.SyntaxKind.PrivateKeyword)
+                    return true;
+            }
+        }
+        return false;
+    }
+    isExported(node) {
+        const modifiers = ts.getModifiers(node);
+        if (modifiers) {
+            for (const mod of modifiers) {
+                if (mod.kind === ts.SyntaxKind.ExportKeyword)
+                    return true;
+            }
+        }
+        // Also check for default export or if it's a top-level declaration in a module
+        return false;
+    }
+    getPropertyName(name) {
+        if (ts.isIdentifier(name))
+            return name.text;
+        if (ts.isStringLiteral(name))
+            return name.text;
+        return undefined;
+    }
+    extractFunction(node, sourceFile, filePath) {
+        const name = node.name?.text ?? 'anonymous';
+        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        return {
+            kind: 'function',
+            name,
+            signature: this.buildSignature(node, sourceFile),
+            parameters: this.extractParameters(node.parameters, sourceFile),
+            returnType: node.type ? node.type.getText(sourceFile) : undefined,
+            docstring: this.getJSDoc(node, sourceFile),
+            filePath,
+            lineNumber: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+            isAsync,
+            isExported: true,
+            isPublic: true
+        };
+    }
+    extractArrowFunction(decl, fn, sourceFile, filePath) {
+        const name = ts.isIdentifier(decl.name) ? decl.name.text : 'anonymous';
+        const isAsync = fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        return {
+            kind: 'function',
+            name,
+            signature: this.buildArrowSignature(decl, fn, sourceFile),
+            parameters: this.extractParameters(fn.parameters, sourceFile),
+            returnType: fn.type ? fn.type.getText(sourceFile) : undefined,
+            docstring: this.getJSDoc(decl.parent.parent, sourceFile),
+            filePath,
+            lineNumber: sourceFile.getLineAndCharacterOfPosition(decl.getStart()).line + 1,
+            isAsync,
+            isExported: true,
+            isPublic: true
+        };
+    }
+    extractClass(node, sourceFile, filePath) {
+        const name = node.name?.text ?? 'AnonymousClass';
+        let signature = `class ${name}`;
+        if (node.heritageClauses) {
+            for (const clause of node.heritageClauses) {
+                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                    signature += ` extends ${clause.types.map(t => t.getText(sourceFile)).join(', ')}`;
+                }
+                if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                    signature += ` implements ${clause.types.map(t => t.getText(sourceFile)).join(', ')}`;
+                }
+            }
+        }
+        return {
+            kind: 'class',
+            name,
+            signature,
+            parameters: [],
+            docstring: this.getJSDoc(node, sourceFile),
+            filePath,
+            lineNumber: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+            isExported: true,
+            isPublic: true
+        };
+    }
+    extractMethod(node, sourceFile, filePath, parentClass) {
+        const name = this.getPropertyName(node.name) ?? 'anonymous';
+        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        return {
+            kind: 'method',
+            name,
+            signature: this.buildMethodSignature(node, sourceFile),
+            parameters: this.extractParameters(node.parameters, sourceFile),
+            returnType: node.type ? node.type.getText(sourceFile) : undefined,
+            docstring: this.getJSDoc(node, sourceFile),
+            filePath,
+            lineNumber: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+            parentClass,
+            isAsync,
+            isPublic: true
+        };
+    }
+    extractConstructor(node, sourceFile, filePath, parentClass) {
+        return {
+            kind: 'method',
+            name: 'constructor',
+            signature: this.buildConstructorSignature(node, sourceFile),
+            parameters: this.extractParameters(node.parameters, sourceFile),
+            docstring: this.getJSDoc(node, sourceFile),
+            filePath,
+            lineNumber: sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+            parentClass,
+            isPublic: true
+        };
+    }
+    extractParameters(params, sourceFile) {
+        return params.map(p => {
+            const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText(sourceFile);
+            return {
+                name: p.dotDotDotToken ? `...${name}` : name,
+                type: p.type ? p.type.getText(sourceFile) : undefined,
+                default: p.initializer ? p.initializer.getText(sourceFile) : undefined
+            };
+        });
+    }
+    buildSignature(node, sourceFile) {
+        const async = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const name = node.name.text;
+        const typeParams = node.typeParameters
+            ? `<${node.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`
+            : '';
+        const params = node.parameters.map(p => p.getText(sourceFile)).join(', ');
+        const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+        return `${async}function ${name}${typeParams}(${params})${returnType}`;
+    }
+    buildArrowSignature(decl, fn, sourceFile) {
+        const name = decl.name.text;
+        const async = fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const typeParams = fn.typeParameters
+            ? `<${fn.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`
+            : '';
+        const params = fn.parameters.map(p => p.getText(sourceFile)).join(', ');
+        const returnType = fn.type ? `: ${fn.type.getText(sourceFile)}` : '';
+        return `const ${name} = ${async}${typeParams}(${params})${returnType} => ...`;
+    }
+    buildMethodSignature(node, sourceFile) {
+        const async = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const name = this.getPropertyName(node.name);
+        const typeParams = node.typeParameters
+            ? `<${node.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`
+            : '';
+        const params = node.parameters.map(p => p.getText(sourceFile)).join(', ');
+        const returnType = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+        return `${async}${name}${typeParams}(${params})${returnType}`;
+    }
+    buildConstructorSignature(node, sourceFile) {
+        const params = node.parameters.map(p => p.getText(sourceFile)).join(', ');
+        return `constructor(${params})`;
+    }
+    getJSDoc(node, sourceFile) {
+        // TypeScript's JSDoc is not in public types but exists at runtime
+        const jsDocNodes = node.jsDoc;
+        if (!jsDocNodes || jsDocNodes.length === 0)
+            return undefined;
+        const jsDoc = jsDocNodes[0];
+        if (jsDoc.comment) {
+            if (typeof jsDoc.comment === 'string') {
+                return jsDoc.comment;
+            }
+            // Handle JSDocComment[] for complex comments
+            return jsDoc.comment.map(c => c.getText(sourceFile)).join('');
+        }
+        return undefined;
+    }
+}

package/dist/scanner/typescript.manual-test.d.ts

@@ -0,0 +1 @@
+export {};