skrypt-ai 0.7.0 → 0.8.0

package/dist/generator/generator.test.d.ts

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

package/dist/generator/generator.test.js

@@ -1,259 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { formatAsMarkdown, generateForElement, generateForElements } from './generator.js';
-// Mock API elements for testing
-function createMockElement(overrides = {}) {
-    return {
-        kind: 'function',
-        name: 'testFunction',
-        signature: 'function testFunction(arg: string): void',
-        parameters: [{ name: 'arg', type: 'string' }],
-        returnType: 'void',
-        docstring: 'Test docstring',
-        filePath: '/test/file.ts',
-        lineNumber: 1,
-        isExported: true,
-        isPublic: true,
-        ...overrides
-    };
-}
-// Mock generated doc for testing
-function createMockDoc(overrides = {}) {
-    return {
-        element: createMockElement(overrides.element),
-        markdown: 'Test markdown documentation',
-        codeExample: 'const example = "test"',
-        codeLanguage: 'typescript',
-        ...overrides
-    };
-}
-// Create a mock LLM client
-function createMockLLMClient(response) {
-    const defaultResponse = {
-        content: `---MARKDOWN---
-Use this to perform a test operation.
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| arg | string | Yes | The test argument |
-
-Returns void.
----CODE---
-const result = testFunction('hello')
-console.log(result)
----END---`,
-        model: 'test-model',
-        usage: { inputTokens: 100, outputTokens: 200, totalTokens: 300 },
-        finishReason: 'stop',
-        ...response
-    };
-    return {
-        provider: 'openai',
-        complete: vi.fn().mockResolvedValue(defaultResponse),
-        isConfigured: vi.fn().mockReturnValue(true)
-    };
-}
-describe('Generator', () => {
-    describe('formatAsMarkdown', () => {
-        it('should format a single function doc as markdown', () => {
-            const docs = [createMockDoc({ element: { kind: 'function', name: 'greet' } })];
-            const result = formatAsMarkdown(docs, 'API Reference');
-            expect(result).toContain('# API Reference');
-            expect(result).toContain('## Functions');
-            expect(result).toContain('### `greet`');
-            expect(result).toContain('Test markdown documentation');
-        });
-        it('should format classes and methods with proper hierarchy', () => {
-            const classDoc = createMockDoc({
-                element: { kind: 'class', name: 'Calculator' },
-                markdown: 'A calculator class'
-            });
-            const methodDoc = createMockDoc({
-                element: { kind: 'method', name: 'add', parentClass: 'Calculator' },
-                markdown: 'Adds two numbers'
-            });
-            const result = formatAsMarkdown([classDoc, methodDoc], 'Calculator API');
-            expect(result).toContain('## Classes');
-            expect(result).toContain('### `Calculator`');
-            expect(result).toContain('### Methods');
-            expect(result).toContain('#### `add`');
-        });
-        it('should group functions and classes separately', () => {
-            const funcDoc = createMockDoc({
-                element: { kind: 'function', name: 'helper' }
-            });
-            const classDoc = createMockDoc({
-                element: { kind: 'class', name: 'Service' }
-            });
-            const result = formatAsMarkdown([funcDoc, classDoc], 'Mixed API');
-            expect(result).toContain('## Functions');
-            expect(result).toContain('## Classes');
-            expect(result.indexOf('## Functions')).toBeLessThan(result.indexOf('## Classes'));
-        });
-        it('should include code examples in markdown', () => {
-            const doc = createMockDoc({
-                codeExample: 'const x = doSomething()',
-                codeLanguage: 'typescript'
-            });
-            const result = formatAsMarkdown([doc], 'Test');
-            expect(result).toContain('**Example:**');
-            expect(result).toContain('```typescript');
-            expect(result).toContain('const x = doSomething()');
-        });
-        it('should handle multi-language examples with CodeGroup', () => {
-            const doc = createMockDoc({
-                typescriptExample: 'const x = 1',
-                pythonExample: 'x = 1',
-                codeExample: 'const x = 1'
-            });
-            const result = formatAsMarkdown([doc], 'Multi-lang Test');
-            expect(result).toContain('**Examples:**');
-            expect(result).toContain('<CodeGroup>');
-            expect(result).toContain('```typescript example.ts');
-            expect(result).toContain('```python example.py');
-            expect(result).toContain('</CodeGroup>');
-        });
-        it('should detect Python language from file path', () => {
-            const doc = createMockDoc({
-                element: { kind: 'function', name: 'greet', filePath: '/test/file.py' },
-                codeLanguage: 'python',
-                codeExample: 'print("hello")'
-            });
-            const result = formatAsMarkdown([doc], 'Python Test');
-            expect(result).toContain('```python');
-            expect(result).toContain('print("hello")');
-        });
-        it('should handle empty docs array', () => {
-            const result = formatAsMarkdown([], 'Empty');
-            expect(result).toBe('# Empty\n\n');
-        });
-        it('should handle methods without matching parent class', () => {
-            const orphanMethod = createMockDoc({
-                element: { kind: 'method', name: 'orphan', parentClass: 'NonExistent' }
-            });
-            // Methods without matching class doc should not appear under a class section
-            const result = formatAsMarkdown([orphanMethod], 'Test');
-            // The method will not be rendered because there's no class section
-            // and methods are only rendered under their parent class
-            expect(result).not.toContain('### `orphan`');
-        });
-    });
-    describe('generateForElement', () => {
-        let mockClient;
-        beforeEach(() => {
-            mockClient = createMockLLMClient();
-        });
-        it('should generate documentation for an element', async () => {
-            const element = createMockElement();
-            const options = {};
-            const result = await generateForElement(element, mockClient, options);
-            expect(result.element).toBe(element);
-            expect(result.markdown).toBeTruthy();
-            expect(result.codeLanguage).toBe('typescript');
-            expect(mockClient.complete).toHaveBeenCalled();
-        });
-        it('should detect language from file extension', async () => {
-            const pythonElement = createMockElement({ filePath: '/test/file.py' });
-            const result = await generateForElement(pythonElement, mockClient, {});
-            expect(result.codeLanguage).toBe('python');
-        });
-        it('should detect Go language from file extension', async () => {
-            const goElement = createMockElement({ filePath: '/test/file.go' });
-            const result = await generateForElement(goElement, mockClient, {});
-            expect(result.codeLanguage).toBe('go');
-        });
-        it('should detect Rust language from file extension', async () => {
-            const rustElement = createMockElement({ filePath: '/test/file.rs' });
-            const result = await generateForElement(rustElement, mockClient, {});
-            expect(result.codeLanguage).toBe('rust');
-        });
-        it('should call progress callback with correct status', async () => {
-            const element = createMockElement();
-            const onProgress = vi.fn();
-            await generateForElement(element, mockClient, {}, onProgress);
-            expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ status: 'generating', element: 'testFunction' }));
-            expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ status: 'done', element: 'testFunction' }));
-        });
-        it('should handle LLM errors gracefully', async () => {
-            const failingClient = createMockLLMClient();
-            vi.mocked(failingClient.complete).mockRejectedValue(new Error('API Error'));
-            const element = createMockElement();
-            const onProgress = vi.fn();
-            const result = await generateForElement(element, failingClient, {}, onProgress);
-            expect(result.error).toContain('Failed to generate');
-            expect(result.markdown).toBe('');
-            expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ status: 'failed' }));
-        });
-        it('should use multi-language option when specified', async () => {
-            const multiLangClient = createMockLLMClient({
-                content: `---MARKDOWN---
-Multi-lang docs
----TYPESCRIPT---
-const x = 1
----PYTHON---
-x = 1
----END---`
-            });
-            const element = createMockElement();
-            const result = await generateForElement(element, multiLangClient, { multiLanguage: true });
-            expect(result.typescriptExample).toBeTruthy();
-            expect(result.pythonExample).toBeTruthy();
-        });
-    });
-    describe('generateForElements', () => {
-        let mockClient;
-        beforeEach(() => {
-            mockClient = createMockLLMClient();
-        });
-        it('should generate docs for multiple elements', async () => {
-            const elements = [
-                createMockElement({ name: 'func1' }),
-                createMockElement({ name: 'func2' }),
-                createMockElement({ name: 'func3' })
-            ];
-            const results = await generateForElements(elements, mockClient, {});
-            expect(results).toHaveLength(3);
-            expect(mockClient.complete).toHaveBeenCalledTimes(3);
-        });
-        it('should call progress callback with correct counts', async () => {
-            const elements = [
-                createMockElement({ name: 'func1' }),
-                createMockElement({ name: 'func2' })
-            ];
-            const onProgress = vi.fn();
-            await generateForElements(elements, mockClient, { onProgress });
-            expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ current: 1, total: 2 }));
-            expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ current: 2, total: 2 }));
-        });
-        it('should handle empty elements array', async () => {
-            const results = await generateForElements([], mockClient, {});
-            expect(results).toHaveLength(0);
-            expect(mockClient.complete).not.toHaveBeenCalled();
-        });
-        it('should continue processing after errors', async () => {
-            const failOnSecond = createMockLLMClient();
-            let callCount = 0;
-            vi.mocked(failOnSecond.complete).mockImplementation(async () => {
-                callCount++;
-                if (callCount === 2) {
-                    throw new Error('API Error');
-                }
-                return {
-                    content: '---MARKDOWN---\nDocs\n---CODE---\ncode\n---END---',
-                    model: 'test',
-                    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                    finishReason: 'stop'
-                };
-            });
-            const elements = [
-                createMockElement({ name: 'func1' }),
-                createMockElement({ name: 'func2' }),
-                createMockElement({ name: 'func3' })
-            ];
-            const results = await generateForElements(elements, failOnSecond, {});
-            expect(results).toHaveLength(3);
-            expect(results[1]?.error).toBeTruthy();
-            expect(results[0]?.error).toBeUndefined();
-            expect(results[2]?.error).toBeUndefined();
-        });
-    });
-});

package/dist/generator/writer.test.d.ts

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

package/dist/generator/writer.test.js

@@ -1,411 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdir, rm, readFile, readdir } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { randomUUID } from 'crypto';
-import { groupDocsByFile, writeDocsToDirectory, writeLlmsTxt, writeDocsByTopic } from './writer.js';
-// Create test fixtures
-function createMockElement(overrides = {}) {
-    return {
-        kind: 'function',
-        name: 'testFunction',
-        signature: 'function testFunction(arg: string): void',
-        parameters: [{ name: 'arg', type: 'string' }],
-        returnType: 'void',
-        docstring: 'Test docstring',
-        filePath: '/test/src/file.ts',
-        lineNumber: 1,
-        isExported: true,
-        isPublic: true,
-        ...overrides
-    };
-}
-function createMockDoc(overrides = {}) {
-    return {
-        element: createMockElement(overrides.element),
-        markdown: 'Use this to perform a test operation. It helps you do things.',
-        codeExample: 'const result = testFunction("hello")\nconsole.log(result)',
-        codeLanguage: 'typescript',
-        ...overrides
-    };
-}
-describe('Writer', () => {
-    describe('groupDocsByFile', () => {
-        it('should group docs by their file path', () => {
-            const docs = [
-                createMockDoc({ element: { filePath: '/src/a.ts', name: 'func1' } }),
-                createMockDoc({ element: { filePath: '/src/a.ts', name: 'func2' } }),
-                createMockDoc({ element: { filePath: '/src/b.ts', name: 'func3' } })
-            ];
-            const result = groupDocsByFile(docs);
-            expect(result).toHaveLength(2);
-            expect(result.find(r => r.filePath === '/src/a.ts')?.docs).toHaveLength(2);
-            expect(result.find(r => r.filePath === '/src/b.ts')?.docs).toHaveLength(1);
-        });
-        it('should handle empty docs array', () => {
-            const result = groupDocsByFile([]);
-            expect(result).toHaveLength(0);
-        });
-        it('should preserve doc properties when grouping', () => {
-            const doc = createMockDoc({
-                element: { filePath: '/src/test.ts', name: 'myFunc' },
-                markdown: 'My documentation',
-                codeExample: 'myFunc()'
-            });
-            const result = groupDocsByFile([doc]);
-            expect(result[0]?.docs[0]?.markdown).toBe('My documentation');
-            expect(result[0]?.docs[0]?.codeExample).toBe('myFunc()');
-        });
-        it('should handle single file with multiple functions', () => {
-            const docs = [
-                createMockDoc({ element: { filePath: '/src/utils.ts', name: 'func1' } }),
-                createMockDoc({ element: { filePath: '/src/utils.ts', name: 'func2' } }),
-                createMockDoc({ element: { filePath: '/src/utils.ts', name: 'func3' } }),
-                createMockDoc({ element: { filePath: '/src/utils.ts', name: 'func4' } })
-            ];
-            const result = groupDocsByFile(docs);
-            expect(result).toHaveLength(1);
-            expect(result[0]?.docs).toHaveLength(4);
-        });
-    });
-    describe('writeDocsToDirectory', () => {
-        let tempDir;
-        let sourceDir;
-        beforeEach(async () => {
-            tempDir = join(tmpdir(), `autodocs-test-${randomUUID()}`);
-            sourceDir = join(tempDir, 'source');
-            await mkdir(sourceDir, { recursive: true });
-        });
-        afterEach(async () => {
-            try {
-                await rm(tempDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        });
-        it('should write docs to output directory', async () => {
-            const outputDir = join(tempDir, 'output');
-            const results = [
-                {
-                    filePath: join(sourceDir, 'utils.ts'),
-                    docs: [createMockDoc({ element: { name: 'helper', filePath: join(sourceDir, 'utils.ts') } })]
-                }
-            ];
-            const { filesWritten, totalDocs } = await writeDocsToDirectory(results, outputDir, sourceDir);
-            expect(filesWritten).toBe(1);
-            expect(totalDocs).toBe(1);
-            // Check file was created
-            const files = await readdir(outputDir);
-            expect(files).toContain('utils.md');
-            expect(files).toContain('README.md');
-        });
-        it('should create nested directory structure', async () => {
-            const outputDir = join(tempDir, 'output');
-            await mkdir(join(sourceDir, 'nested', 'deep'), { recursive: true });
-            const results = [
-                {
-                    filePath: join(sourceDir, 'nested', 'deep', 'module.ts'),
-                    docs: [createMockDoc({
-                            element: { kind: 'function', name: 'deepFunc', filePath: join(sourceDir, 'nested', 'deep', 'module.ts') }
-                        })]
-                }
-            ];
-            await writeDocsToDirectory(results, outputDir, sourceDir);
-            const content = await readFile(join(outputDir, 'nested', 'deep', 'module.md'), 'utf-8');
-            expect(content).toContain('# Module');
-            expect(content).toContain('deepFunc');
-        });
-        it('should skip empty results', async () => {
-            const outputDir = join(tempDir, 'output');
-            const results = [
-                { filePath: join(sourceDir, 'empty.ts'), docs: [] },
-                {
-                    filePath: join(sourceDir, 'full.ts'),
-                    docs: [createMockDoc({ element: { name: 'func', filePath: join(sourceDir, 'full.ts') } })]
-                }
-            ];
-            const { filesWritten } = await writeDocsToDirectory(results, outputDir, sourceDir);
-            expect(filesWritten).toBe(1);
-            const files = await readdir(outputDir);
-            expect(files).toContain('full.md');
-            expect(files).not.toContain('empty.md');
-        });
-        it('should generate README index file', async () => {
-            const outputDir = join(tempDir, 'output');
-            const results = [
-                {
-                    filePath: join(sourceDir, 'api.ts'),
-                    docs: [createMockDoc({ element: { name: 'apiFunc', filePath: join(sourceDir, 'api.ts') } })]
-                },
-                {
-                    filePath: join(sourceDir, 'utils.ts'),
-                    docs: [
-                        createMockDoc({ element: { name: 'util1', filePath: join(sourceDir, 'utils.ts') } }),
-                        createMockDoc({ element: { name: 'util2', filePath: join(sourceDir, 'utils.ts') } })
-                    ]
-                }
-            ];
-            await writeDocsToDirectory(results, outputDir, sourceDir);
-            const readme = await readFile(join(outputDir, 'README.md'), 'utf-8');
-            expect(readme).toContain('# API Documentation');
-            expect(readme).toContain('api.ts');
-            expect(readme).toContain('utils.ts');
-            expect(readme).toContain('(1 elements)');
-            expect(readme).toContain('(2 elements)');
-        });
-        it('should format title from filename', async () => {
-            const outputDir = join(tempDir, 'output');
-            const results = [
-                {
-                    filePath: join(sourceDir, 'user_service.py'),
-                    docs: [createMockDoc({
-                            element: { name: 'getUser', filePath: join(sourceDir, 'user_service.py') }
-                        })]
-                }
-            ];
-            await writeDocsToDirectory(results, outputDir, sourceDir);
-            const content = await readFile(join(outputDir, 'user_service.md'), 'utf-8');
-            expect(content).toContain('# User service');
-        });
-        it('should skip files outside source directory', async () => {
-            const outputDir = join(tempDir, 'output');
-            const results = [
-                {
-                    filePath: '/outside/path/evil.ts', // Outside source directory
-                    docs: [createMockDoc({ element: { name: 'evil', filePath: '/outside/path/evil.ts' } })]
-                },
-                {
-                    filePath: join(sourceDir, 'good.ts'),
-                    docs: [createMockDoc({ element: { name: 'good', filePath: join(sourceDir, 'good.ts') } })]
-                }
-            ];
-            const { filesWritten } = await writeDocsToDirectory(results, outputDir, sourceDir);
-            expect(filesWritten).toBe(1);
-        });
-    });
-    describe('writeLlmsTxt', () => {
-        let tempDir;
-        beforeEach(async () => {
-            tempDir = join(tmpdir(), `autodocs-llms-${randomUUID()}`);
-            await mkdir(tempDir, { recursive: true });
-        });
-        afterEach(async () => {
-            try {
-                await rm(tempDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        });
-        it('should write llms.txt file', async () => {
-            const docs = [
-                createMockDoc({ element: { name: 'func1', filePath: '/src/api.ts' } }),
-                createMockDoc({ element: { name: 'func2', filePath: '/src/api.ts' } })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('# API');
-            expect(content).toContain('func1');
-            expect(content).toContain('func2');
-        });
-        it('should use custom project name and description', async () => {
-            const docs = [createMockDoc()];
-            await writeLlmsTxt(docs, tempDir, {
-                projectName: 'My Project',
-                description: 'A custom description'
-            });
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('# My Project');
-            expect(content).toContain('> A custom description');
-        });
-        it('should include overview section', async () => {
-            const docs = [
-                createMockDoc({ element: { name: 'func1', filePath: '/src/module1.ts' } }),
-                createMockDoc({ element: { name: 'func2', filePath: '/src/module2.ts' } })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('## Overview');
-            expect(content).toContain('2 documented API elements');
-            expect(content).toContain('2 modules');
-        });
-        it('should include quick reference section', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'greet', kind: 'function', filePath: '/src/utils.ts' },
-                    markdown: 'Generate a greeting message. Use this for welcoming users.'
-                })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('## Quick Reference');
-            expect(content).toContain('### utils');
-            expect(content).toContain('`greet`: function');
-        });
-        it('should include API details section', async () => {
-            const docs = [
-                createMockDoc({
-                    element: {
-                        name: 'calculate',
-                        kind: 'function',
-                        signature: 'function calculate(a: number, b: number): number',
-                        filePath: '/src/math.ts'
-                    },
-                    codeExample: 'const sum = calculate(1, 2)'
-                })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('## API Details');
-            expect(content).toContain('### calculate');
-            expect(content).toContain('**Type:** function');
-            expect(content).toContain('**File:**');
-            expect(content).toContain('**Example:**');
-        });
-        it('should also write llms-full.md', async () => {
-            const docs = [createMockDoc()];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms-full.md'), 'utf-8');
-            expect(content).toContain('# API');
-            expect(content).toContain('## testFunction');
-        });
-        it('should handle docs without markdown', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'noDoc', filePath: '/src/test.ts' },
-                    markdown: ''
-                })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            expect(content).toContain('noDoc');
-        });
-        it('should truncate long content', async () => {
-            const longMarkdown = 'A'.repeat(1000);
-            const docs = [
-                createMockDoc({
-                    element: { name: 'longDoc', filePath: '/src/test.ts' },
-                    markdown: longMarkdown
-                })
-            ];
-            await writeLlmsTxt(docs, tempDir);
-            const content = await readFile(join(tempDir, 'llms.txt'), 'utf-8');
-            // Content should be truncated to 500 chars
-            expect(content.length).toBeLessThan(longMarkdown.length + 500);
-        });
-    });
-    describe('writeDocsByTopic', () => {
-        let tempDir;
-        beforeEach(async () => {
-            tempDir = join(tmpdir(), `autodocs-topic-${randomUUID()}`);
-            await mkdir(tempDir, { recursive: true });
-        });
-        afterEach(async () => {
-            try {
-                await rm(tempDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        });
-        it('should organize docs by topic', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'createTool', kind: 'function', filePath: '/src/tools/helper.ts' }
-                }),
-                createMockDoc({
-                    element: { name: 'saveMemory', kind: 'function', filePath: '/src/memory/store.ts' }
-                })
-            ];
-            const { filesWritten, topics } = await writeDocsByTopic(docs, tempDir);
-            expect(filesWritten).toBeGreaterThan(0);
-            expect(topics.length).toBeGreaterThan(0);
-        });
-        it('should write index.mdx file', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'coreFunc', kind: 'function', filePath: '/src/core/main.ts' }
-                })
-            ];
-            await writeDocsByTopic(docs, tempDir);
-            const content = await readFile(join(tempDir, 'index.mdx'), 'utf-8');
-            expect(content).toContain('title: "API Reference"');
-            expect(content).toContain('<CardGroup');
-        });
-        it('should write navigation config', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'toolFunc', kind: 'function', filePath: '/src/tools.ts' }
-                })
-            ];
-            await writeDocsByTopic(docs, tempDir);
-            const navContent = await readFile(join(tempDir, '_navigation.json'), 'utf-8');
-            const nav = JSON.parse(navContent);
-            expect(nav).toHaveProperty('navigation');
-            expect(nav).toHaveProperty('groups');
-        });
-        it('should write sidebar config', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'utilFunc', kind: 'function', filePath: '/src/utils.ts' }
-                })
-            ];
-            await writeDocsByTopic(docs, tempDir);
-            const sidebarContent = await readFile(join(tempDir, '_sidebars.json'), 'utf-8');
-            const sidebar = JSON.parse(sidebarContent);
-            expect(sidebar).toHaveProperty('apiSidebar');
-        });
-        it('should include cross-references in topic files', async () => {
-            const docs = [
-                createMockDoc({
-                    element: {
-                        name: 'parentClass',
-                        kind: 'class',
-                        filePath: '/src/core.ts',
-                        sourceContext: 'class parentClass { childMethod() {} }'
-                    }
-                }),
-                createMockDoc({
-                    element: {
-                        name: 'childMethod',
-                        kind: 'method',
-                        parentClass: 'parentClass',
-                        filePath: '/src/core.ts'
-                    }
-                })
-            ];
-            const { topics } = await writeDocsByTopic(docs, tempDir);
-            expect(topics.length).toBeGreaterThan(0);
-        });
-        it('should return topic statistics', async () => {
-            const docs = [
-                createMockDoc({ element: { name: 'func1', filePath: '/src/a.ts' } }),
-                createMockDoc({ element: { name: 'func2', filePath: '/src/b.ts' } }),
-                createMockDoc({ element: { name: 'func3', filePath: '/src/c.ts' } })
-            ];
-            const { totalDocs, topics } = await writeDocsByTopic(docs, tempDir);
-            expect(totalDocs).toBe(3);
-            expect(topics.length).toBeGreaterThan(0);
-        });
-        it('should handle multi-language examples in topic output', async () => {
-            const docs = [
-                createMockDoc({
-                    element: { name: 'multiLangFunc', filePath: '/src/core.ts' },
-                    typescriptExample: 'const x = 1',
-                    pythonExample: 'x = 1'
-                })
-            ];
-            await writeDocsByTopic(docs, tempDir);
-            // Find the topic file that was written
-            const files = await readdir(tempDir);
-            const topicFile = files.find(f => f.endsWith('.md'));
-            if (topicFile) {
-                const content = await readFile(join(tempDir, topicFile), 'utf-8');
-                expect(content).toContain('<CodeGroup>');
-                expect(content).toContain('```typescript');
-                expect(content).toContain('```python');
-            }
-        });
-    });
-});

package/dist/llm/llm.manual-test.d.ts

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