skrypt-ai 0.1.4 → 0.1.8

package/dist/autofix/autofix.test.d.ts

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

package/dist/autofix/autofix.test.js

@@ -0,0 +1,487 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { autoFixExample, autoFixBatch, createTypeScriptValidator, createPythonValidator } from './index.js';
+// Create a mock LLM client
+function createMockLLMClient(responses) {
+    let callCount = 0;
+    const defaultResponse = '```typescript\nconst x = 1\nconsole.log(x)\n```';
+    return {
+        provider: 'openai',
+        complete: vi.fn().mockImplementation(async () => {
+            const content = responses?.[callCount] ?? defaultResponse;
+            callCount++;
+            return {
+                content,
+                model: 'test-model',
+                usage: { inputTokens: 100, outputTokens: 200, totalTokens: 300 },
+                finishReason: 'stop'
+            };
+        }),
+        isConfigured: vi.fn().mockReturnValue(true)
+    };
+}
+// Mock validator that always passes
+const passingValidator = async () => ({
+    valid: true,
+    errors: []
+});
+// Mock validator that always fails
+const failingValidator = async (code) => ({
+    valid: false,
+    errors: [`Syntax error in: ${code.slice(0, 20)}...`]
+});
+// Mock validator that fails N times then passes
+function createCountingValidator(failTimes) {
+    let count = 0;
+    return async () => {
+        count++;
+        if (count <= failTimes) {
+            return { valid: false, errors: [`Failure ${count}`] };
+        }
+        return { valid: true, errors: [] };
+    };
+}
+describe('Autofix', () => {
+    describe('Code Block Extraction', () => {
+        it('should extract code from language-specific code blocks', async () => {
+            const client = createMockLLMClient([
+                '```typescript\nconst result = "fixed"\n```'
+            ]);
+            const example = {
+                code: 'const result = broken',
+                language: 'typescript',
+                context: 'A simple variable assignment'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 3
+            });
+            expect(result.success).toBe(true);
+            expect(result.fixedCode).toContain('const result');
+        });
+        it('should extract code from generic code blocks', async () => {
+            const client = createMockLLMClient([
+                '```\nconst generic = "code"\n```'
+            ]);
+            const example = {
+                code: 'broken code',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 3
+            });
+            expect(result.success).toBe(true);
+            expect(result.fixedCode).toContain('generic');
+        });
+        it('should extract code without code fences', async () => {
+            const client = createMockLLMClient([
+                'const noFences = "extracted"'
+            ]);
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 3
+            });
+            expect(result.success).toBe(true);
+            expect(result.fixedCode).toContain('noFences');
+        });
+        it('should handle Python code blocks', async () => {
+            const client = createMockLLMClient([
+                '```python\ndef fixed():\n    return True\n```'
+            ]);
+            const example = {
+                code: 'def broken():\n    return',
+                language: 'python',
+                context: 'A Python function'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 3
+            });
+            expect(result.success).toBe(true);
+            expect(result.fixedCode).toContain('def fixed');
+        });
+    });
+    describe('autoFixExample', () => {
+        let mockClient;
+        beforeEach(() => {
+            mockClient = createMockLLMClient();
+        });
+        it('should return immediately if code is already valid', async () => {
+            const example = {
+                code: 'const x = 1',
+                language: 'typescript',
+                context: 'Valid code'
+            };
+            const result = await autoFixExample(example, mockClient, {
+                validateFn: passingValidator
+            });
+            expect(result.success).toBe(true);
+            expect(result.iterations).toBe(0);
+            expect(result.fixedCode).toBe('const x = 1');
+            expect(result.explanation).toContain('no fixes needed');
+            expect(mockClient.complete).not.toHaveBeenCalled();
+        });
+        it('should fix code after one iteration', async () => {
+            const client = createMockLLMClient([
+                '```typescript\nconst fixed = "value"\n```'
+            ]);
+            const example = {
+                code: 'const broken =',
+                language: 'typescript',
+                context: 'Variable assignment'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 3
+            });
+            expect(result.success).toBe(true);
+            expect(result.iterations).toBe(1);
+        });
+        it('should retry up to maxIterations', async () => {
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, mockClient, {
+                validateFn: failingValidator,
+                maxIterations: 3
+            });
+            expect(result.success).toBe(false);
+            expect(result.iterations).toBe(3);
+            expect(mockClient.complete).toHaveBeenCalledTimes(3);
+        });
+        it('should use default max iterations of 3', async () => {
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, mockClient, {
+                validateFn: failingValidator
+            });
+            expect(result.iterations).toBe(3);
+        });
+        it('should accumulate errors across iterations', async () => {
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, mockClient, {
+                validateFn: failingValidator,
+                maxIterations: 2
+            });
+            expect(result.errors.length).toBeGreaterThan(1);
+        });
+        it('should fix code after multiple iterations', async () => {
+            const client = createMockLLMClient([
+                '```typescript\nstill broken\n```',
+                '```typescript\nconst fixed = true\n```'
+            ]);
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(2),
+                maxIterations: 5
+            });
+            expect(result.success).toBe(true);
+            expect(result.iterations).toBe(2);
+        });
+        it('should handle LLM returning empty response', async () => {
+            const client = createMockLLMClient(['', '', '']);
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: failingValidator,
+                maxIterations: 3
+            });
+            expect(result.success).toBe(false);
+            expect(result.errors.some(e => e.includes('Could not extract code'))).toBe(true);
+        });
+        it('should use custom language option', async () => {
+            const client = createMockLLMClient(['```python\nprint("fixed")\n```']);
+            const example = {
+                code: 'print(broken)',
+                language: 'python',
+                context: 'Python print'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                language: 'python'
+            });
+            expect(result.success).toBe(true);
+            expect(result.fixedCode).toContain('print');
+        });
+    });
+    describe('TypeScript Validator', () => {
+        it('should validate correct TypeScript code', async () => {
+            const validator = createTypeScriptValidator();
+            const result = await validator('const x: number = 1');
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should detect TypeScript syntax errors', async () => {
+            const validator = createTypeScriptValidator();
+            const result = await validator('const x: number = "string"');
+            // TypeScript transpiles this, so it may or may not error
+            // depending on strict mode and compiler options
+            expect(result).toBeDefined();
+        });
+        it('should handle complex TypeScript code', async () => {
+            const validator = createTypeScriptValidator();
+            const code = `
+interface User {
+  name: string
+  age: number
+}
+
+function greet(user: User): string {
+  return \`Hello, \${user.name}!\`
+}
+
+const result = greet({ name: "Test", age: 25 })
+console.log(result)
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(true);
+        });
+        it('should handle async TypeScript code', async () => {
+            const validator = createTypeScriptValidator();
+            const code = `
+async function fetchData(): Promise<string> {
+  return "data"
+}
+
+async function main() {
+  try {
+    const data = await fetchData()
+    console.log(data)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+main()
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe('Python Validator', () => {
+        it('should validate correct Python code', async () => {
+            const validator = createPythonValidator();
+            const result = await validator('x = 1\nprint(x)');
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should detect Python syntax errors', async () => {
+            const validator = createPythonValidator();
+            const result = await validator('def broken(\n    return x');
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+        });
+        it('should handle Python functions', async () => {
+            const validator = createPythonValidator();
+            const code = `
+def greet(name: str) -> str:
+    return f"Hello, {name}!"
+
+result = greet("Test")
+print(result)
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(true);
+        });
+        it('should handle Python classes', async () => {
+            const validator = createPythonValidator();
+            const code = `
+class Calculator:
+    def __init__(self, value: int = 0):
+        self.value = value
+
+    def add(self, x: int) -> int:
+        self.value += x
+        return self.value
+
+calc = Calculator(10)
+print(calc.add(5))
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(true);
+        });
+        it('should handle async Python code', async () => {
+            const validator = createPythonValidator();
+            const code = `
+import asyncio
+
+async def fetch_data():
+    return "data"
+
+async def main():
+    result = await fetch_data()
+    print(result)
+
+asyncio.run(main())
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(true);
+        });
+        it('should detect indentation errors', async () => {
+            const validator = createPythonValidator();
+            const code = `
+def broken():
+return "wrong indent"
+`;
+            const result = await validator(code);
+            expect(result.valid).toBe(false);
+        });
+    });
+    describe('autoFixBatch', () => {
+        it('should fix multiple examples', async () => {
+            const client = createMockLLMClient([
+                '```typescript\nconst a = 1\n```',
+                '```typescript\nconst b = 2\n```'
+            ]);
+            const examples = [
+                { code: 'broken1', language: 'typescript', context: 'First' },
+                { code: 'broken2', language: 'typescript', context: 'Second' }
+            ];
+            // Suppress console.log during test
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const results = await autoFixBatch(examples, client, {
+                validateFn: createCountingValidator(1)
+            });
+            consoleSpy.mockRestore();
+            expect(results.size).toBe(2);
+            expect(results.get(0)?.success).toBe(true);
+            expect(results.get(1)?.success).toBe(true);
+        });
+        it('should handle partial failures', async () => {
+            let callCount = 0;
+            const client = {
+                provider: 'openai',
+                complete: vi.fn().mockImplementation(async () => {
+                    callCount++;
+                    return {
+                        content: callCount === 1 ? '```typescript\nfixed\n```' : 'no code here',
+                        model: 'test',
+                        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+                        finishReason: 'stop'
+                    };
+                }),
+                isConfigured: () => true
+            };
+            const examples = [
+                { code: 'first', language: 'typescript', context: 'First' },
+                { code: 'second', language: 'typescript', context: 'Second' }
+            ];
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const results = await autoFixBatch(examples, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 1
+            });
+            consoleSpy.mockRestore();
+            expect(results.size).toBe(2);
+            expect(results.get(0)?.success).toBe(true);
+            // Second one should fail because it can't extract code
+        });
+        it('should return Map with correct indices', async () => {
+            const client = createMockLLMClient();
+            const examples = [
+                { code: 'a', language: 'typescript', context: 'A' },
+                { code: 'b', language: 'typescript', context: 'B' },
+                { code: 'c', language: 'typescript', context: 'C' }
+            ];
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            const results = await autoFixBatch(examples, client, {
+                validateFn: passingValidator
+            });
+            consoleSpy.mockRestore();
+            expect(results.has(0)).toBe(true);
+            expect(results.has(1)).toBe(true);
+            expect(results.has(2)).toBe(true);
+        });
+        it('should handle empty examples array', async () => {
+            const client = createMockLLMClient();
+            const results = await autoFixBatch([], client);
+            expect(results.size).toBe(0);
+            expect(client.complete).not.toHaveBeenCalled();
+        });
+    });
+    describe('Fix Iteration Logic', () => {
+        it('should update currentCode between iterations', async () => {
+            const responses = [
+                '```typescript\nconst step1 = "first"\n```',
+                '```typescript\nconst step2 = "second"\n```',
+                '```typescript\nconst step3 = "final"\n```'
+            ];
+            const client = createMockLLMClient(responses);
+            const example = {
+                code: 'initial broken',
+                language: 'typescript',
+                context: 'Test progression'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: createCountingValidator(3),
+                maxIterations: 5
+            });
+            expect(result.success).toBe(true);
+            expect(result.iterations).toBe(3);
+            expect(result.fixedCode).toContain('step3');
+        });
+        it('should include error context in fix prompt', async () => {
+            const client = createMockLLMClient(['```typescript\nfixed\n```']);
+            const example = {
+                code: 'broken code',
+                language: 'typescript',
+                context: 'Error handling test'
+            };
+            await autoFixExample(example, client, {
+                validateFn: createCountingValidator(1),
+                maxIterations: 2
+            });
+            // Check that complete was called with error context
+            expect(client.complete).toHaveBeenCalled();
+            const callArgs = vi.mocked(client.complete).mock.calls[0]?.[0];
+            expect(callArgs?.messages[1]?.content).toContain('Error');
+        });
+        it('should stop immediately when fix succeeds', async () => {
+            const client = createMockLLMClient([
+                '```typescript\nconst success = true\n```'
+            ]);
+            let validationCalls = 0;
+            const trackingValidator = async () => {
+                validationCalls++;
+                // First call (initial) fails, second call (after first fix) passes
+                return validationCalls > 1
+                    ? { valid: true, errors: [] }
+                    : { valid: false, errors: ['Initial failure'] };
+            };
+            const example = {
+                code: 'broken',
+                language: 'typescript',
+                context: 'Test'
+            };
+            const result = await autoFixExample(example, client, {
+                validateFn: trackingValidator,
+                maxIterations: 5
+            });
+            expect(result.success).toBe(true);
+            expect(result.iterations).toBe(1);
+            expect(client.complete).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/cli.js

@@ -5,7 +5,16 @@ 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.4';
+import { lintCommand } from './commands/lint.js';
+import { checkLinksCommand } from './commands/check-links.js';
+import { mcpCommand } from './commands/mcp.js';
+import { versionCommand } from './commands/version.js';
+import { i18nCommand } from './commands/i18n.js';
+import { monitorCommand } from './commands/monitor.js';
+import { sdkCommand } from './commands/sdk.js';
+import { ghActionCommand } from './commands/gh-action.js';
+import { llmsTxtCommand } from './commands/llms-txt.js';
+const VERSION = '0.1.8';
 async function checkForUpdates() {
     try {
         const res = await fetch('https://registry.npmjs.org/skrypt-ai/latest', {
@@ -37,4 +46,13 @@ program.addCommand(generateCommand);
 program.addCommand(watchCommand);
 program.addCommand(autofixCommand);
 program.addCommand(reviewPRCommand);
+program.addCommand(lintCommand);
+program.addCommand(checkLinksCommand);
+program.addCommand(mcpCommand);
+program.addCommand(versionCommand);
+program.addCommand(i18nCommand);
+program.addCommand(monitorCommand);
+program.addCommand(sdkCommand);
+program.addCommand(ghActionCommand);
+program.addCommand(llmsTxtCommand);
 program.parse();

package/dist/commands/check-links.d.ts

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