qa360 2.1.2 → 2.1.4

package/core/src/repair/engine/__tests__/suggestion-engine.test.ts

@@ -0,0 +1,395 @@
+/**
+ * Unit Tests: Suggestion Engine
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  generateFixSuggestions,
+  getQuickFixes,
+  type SuggestionOptions,
+  type TestError,
+  type FixSuggestion
+} from '../suggestion-engine.js';
+
+// Mock the AI generation module
+vi.mock('../../ai/index.js', () => ({
+  createLLMProvider: vi.fn().mockResolvedValue({
+    generate: vi.fn()
+  })
+}));
+
+import { createLLMProvider } from '../../ai/index.js';
+
+describe('SuggestionEngine', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Mock successful LLM response by default
+    vi.mocked(createLLMProvider).mockResolvedValue({
+      generate: vi.fn().mockResolvedValue({
+        content: '{"fixes": [{"type": "update_expectation", "description": "Fix", "code": "fix", "line": 1, "confidence": 0.8}]}',
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+        model: 'mock',
+        finishReason: 'stop'
+      }),
+      isAvailable: vi.fn().mockResolvedValue(true),
+      countTokens: vi.fn(() => 10),
+      models: [],
+      name: 'mock'
+    } as any);
+  });
+
+  describe('generateFixSuggestions', () => {
+    it('should generate suggestions for assertion errors', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'should return 200',
+        line: 42,
+        type: 'assertion_error',
+        message: 'Expected 200 but got 500',
+        stack: 'Error: Expected 200 but got 500\n    at test.spec.ts:42:10'
+      }];
+
+      const testCode = 'test("should return 200", async () => {\n  const response = await fetch("/api");\n  expect(response.status).toBe(200);\n});';
+
+      const suggestions = await generateFixSuggestions(errors, testCode);
+
+      expect(suggestions).toBeDefined();
+      expect(Array.isArray(suggestions)).toBe(true);
+      expect(suggestions.length).toBeGreaterThan(0);
+    });
+
+    it('should generate suggestions for timeout errors', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'slow test',
+        line: 10,
+        type: 'timeout_error',
+        message: 'Timeout of 5000ms exceeded'
+      }];
+
+      const testCode = 'test("slow test", async () => { await longOperation(); });';
+
+      const suggestions = await generateFixSuggestions(errors, testCode);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions[0].type).toBeDefined();
+    });
+
+    it('should generate suggestions for reference errors', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'undefined var',
+        line: 15,
+        type: 'reference_error',
+        message: 'myFunction is not defined'
+      }];
+
+      const testCode = 'test("test", () => { myFunction(); });';
+
+      const suggestions = await generateFixSuggestions(errors, testCode);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+    });
+
+    it('should generate suggestions for import errors', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'missing import',
+        line: 1,
+        type: 'import_error',
+        message: "Cannot find module './utils'"
+      }];
+
+      const testCode = "import { missing } from './utils';";
+
+      const suggestions = await generateFixSuggestions(errors, testCode);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+    });
+
+    it('should limit suggestions by maxSuggestions', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const testCode = 'test("test", () => {});';
+
+      const suggestions = await generateFixSuggestions(errors, testCode, undefined, {
+        maxSuggestions: 2
+      });
+
+      expect(suggestions.length).toBeLessThanOrEqual(2);
+    });
+
+    it('should sort suggestions by confidence', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const testCode = 'test("test", () => {});';
+
+      const suggestions = await generateFixSuggestions(errors, testCode);
+
+      // Check if sorted by confidence (descending)
+      for (let i = 1; i < suggestions.length; i++) {
+        expect(suggestions[i - 1].confidence).toBeGreaterThanOrEqual(suggestions[i].confidence);
+      }
+    });
+
+    it('should handle empty errors array', async () => {
+      const suggestions = await generateFixSuggestions([], 'test code');
+
+      expect(suggestions).toEqual([]);
+    });
+
+    it('should handle missing source code gracefully', async () => {
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const suggestions = await generateFixSuggestions(errors, 'test code', undefined);
+
+      expect(suggestions).toBeDefined();
+    });
+
+    it('should use fallback when LLM fails', async () => {
+      vi.mocked(createLLMProvider).mockRejectedValue(new Error('LLM unavailable'));
+
+      const errors: TestError[] = [{
+        testFile: 'test.spec.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const suggestions = await generateFixSuggestions(errors, 'test code');
+
+      // Should return fallback suggestions
+      expect(suggestions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getQuickFixes', () => {
+    it('should return quick fix for assertion error', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 42,
+        type: 'assertion_error',
+        message: 'Expected 200 but got 500'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes.length).toBeGreaterThan(0);
+      expect(fixes[0].type).toBe('update_expectation');
+      expect(fixes[0].description).toContain('Update expected');
+    });
+
+    it('should return quick fix for reference error', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 10,
+        type: 'reference_error',
+        message: 'myVar is not defined'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes.length).toBeGreaterThan(0);
+      expect(fixes[0].type).toBe('fix_import');
+      expect(fixes[0].code).toContain('myVar');
+    });
+
+    it('should return quick fix for timeout error', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 5,
+        type: 'timeout_error',
+        message: 'Timeout exceeded'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes.length).toBeGreaterThan(0);
+      expect(fixes[0].type).toBe('fix_timeout');
+      expect(fixes[0].code).toContain('timeout');
+    });
+
+    it('should return quick fix for import error', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'import_error',
+        message: "Cannot find module 'missing-package'"
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes.length).toBeGreaterThan(0);
+      expect(fixes[0].type).toBe('add_dependency');
+      expect(fixes[0].code).toContain('missing-package');
+    });
+
+    it('should return manual review for unknown error types', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'unknown',
+        message: 'Weird error'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes.length).toBeGreaterThan(0);
+      expect(fixes[0].type).toBe('manual_review');
+      expect(fixes[0].confidence).toBeLessThan(0.5);
+    });
+
+    it('should extract missing variable from reference error', () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 10,
+        type: 'reference_error',
+        message: 'ReferenceError: myFunction is not defined'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      expect(fixes[0].code).toContain('myFunction');
+    });
+  });
+
+  describe('suggestion quality', () => {
+    it('should include all required fields in suggestions', async () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      fixes.forEach(fix => {
+        expect(fix.type).toBeDefined();
+        expect(fix.description).toBeDefined();
+        expect(fix.code).toBeDefined();
+        expect(fix.filePath).toBe('test.ts');
+        expect(fix.line).toBe(1);
+        expect(fix.confidence).toBeGreaterThanOrEqual(0);
+        expect(fix.confidence).toBeLessThanOrEqual(1);
+        expect(fix.reason).toBeDefined();
+        expect(['low', 'medium', 'high']).toContain(fix.estimatedEffort);
+      });
+    });
+
+    it('should provide meaningful confidence scores', async () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'timeout_error',
+        message: 'Timeout exceeded'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      // Timeout fixes should have higher confidence
+      expect(fixes[0].confidence).toBeGreaterThan(0.5);
+    });
+
+    it('should provide appropriate effort estimates', async () => {
+      const error: TestError = {
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'reference_error',
+        message: 'x is not defined'
+      };
+
+      const fixes = getQuickFixes(error);
+
+      // Reference errors are usually quick fixes
+      expect(fixes[0].estimatedEffort).toBe('low');
+    });
+  });
+
+  describe('LLM integration', () => {
+    it('should generate suggestions from LLM response', async () => {
+      const mockGenerate = vi.fn().mockResolvedValue({
+        content: JSON.stringify({
+          fixes: [{
+            type: 'update_expectation',
+            description: 'Update expectation',
+            code: 'expect(x).toBe("actual")',
+            line: 1,
+            confidence: 0.9,
+            reason: 'Values do not match',
+            estimatedEffort: 'low'
+          }]
+        }),
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+        model: 'test-model',
+        finishReason: 'stop'
+      });
+
+      vi.mocked(createLLMProvider).mockResolvedValue({
+        generate: mockGenerate,
+        isAvailable: vi.fn().mockResolvedValue(true),
+        countTokens: vi.fn(() => 10),
+        models: [],
+        name: 'test'
+      } as any);
+
+      const errors: TestError[] = [{
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const suggestions = await generateFixSuggestions(errors, 'test code');
+
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions[0].type).toBe('update_expectation');
+    });
+
+    it('should use fallback suggestions when LLM fails', async () => {
+      vi.mocked(createLLMProvider).mockRejectedValue(new Error('LLM error'));
+
+      const errors: TestError[] = [{
+        testFile: 'test.ts',
+        testName: 'test',
+        line: 1,
+        type: 'assertion_error',
+        message: 'Expected A but got B'
+      }];
+
+      const suggestions = await generateFixSuggestions(errors, 'test code');
+
+      // Should fall back to default suggestions
+      expect(suggestions.length).toBeGreaterThan(0);
+    });
+  });
+});

package/core/src/repair/engine/fixer.ts

@@ -0,0 +1,271 @@
+/**
+ * Code Fixer
+ *
+ * Applies fix suggestions to test files.
+ */
+
+import { readFile, writeFile } from 'fs/promises';
+import { join, dirname, basename } from 'path';
+import { mkdirSync, existsSync } from 'fs';
+import type { FixSuggestion, FileChange, FixResult } from '../types.js';
+
+export interface FixerOptions {
+  backup?: boolean;
+  backupDir?: string;
+  dryRun?: boolean;
+  createPatch?: boolean;
+}
+
+/**
+ * Apply fix suggestions to files
+ */
+export async function applyFixes(
+  suggestions: FixSuggestion[],
+  options: FixerOptions = {}
+): Promise<FixResult> {
+  const changes: FileChange[] = [];
+  let applied = 0;
+  let failed = 0;
+
+  // Group suggestions by file
+  const byFile = new Map<string, FixSuggestion[]>();
+  for (const suggestion of suggestions) {
+    if (!byFile.has(suggestion.filePath)) {
+      byFile.set(suggestion.filePath, []);
+    }
+    byFile.get(suggestion.filePath)!.push(suggestion);
+  }
+
+  // Apply fixes per file
+  for (const [filePath, fileSuggestions] of byFile.entries()) {
+    try {
+      const result = await applyFixesToFile(filePath, fileSuggestions, options);
+      changes.push(...result.changes);
+      applied += result.applied;
+      failed += result.failed;
+    } catch (error) {
+      failed++;
+    }
+  }
+
+  return {
+    success: failed === 0,
+    suggestions,
+    applied,
+    failed,
+    testsPassed: 0, // Will be updated by test runner
+    testsFailed: 0,
+    changes
+  };
+}
+
+/**
+ * Apply fixes to a single file
+ */
+async function applyFixesToFile(
+  filePath: string,
+  suggestions: FixSuggestion[],
+  options: FixerOptions
+): Promise<{ changes: FileChange[]; applied: number; failed: number }> {
+  const fullPath = filePath; // Assume relative to cwd or already absolute
+
+  // Read original content
+  const original = await readFile(fullPath, 'utf-8');
+  let modified = original;
+  const changes: FileChange[] = [];
+
+  // Create backup if requested
+  let backupPath = '';
+  if (options.backup) {
+    backupPath = await createBackup(fullPath, options.backupDir);
+  }
+
+  // Apply suggestions in reverse line order (to preserve line numbers)
+  const sortedSuggestions = [...suggestions].sort((a, b) => b.line - a.line);
+
+  for (const suggestion of sortedSuggestions) {
+    try {
+      const result = applySuggestion(modified, suggestion);
+      if (result.changed) {
+        changes.push({
+          path: fullPath,
+          original: modified,
+          modified: result.content,
+          backup: backupPath
+        });
+        modified = result.content;
+      }
+    } catch (error) {
+      // Failed to apply this suggestion
+    }
+  }
+
+  // Write modified content
+  if (!options.dryRun && changes.length > 0) {
+    await writeFile(fullPath, modified, 'utf-8');
+  }
+
+  const applied = changes.length;
+  const failed = suggestions.length - applied;
+
+  return { changes, applied, failed };
+}
+
+/**
+ * Apply a single suggestion to content
+ */
+function applySuggestion(
+  content: string,
+  suggestion: FixSuggestion
+): { changed: boolean; content: string } {
+  const lines = content.split('\n');
+  const lineIndex = suggestion.line - 1; // Convert to 0-based
+
+  if (lineIndex < 0 || lineIndex >= lines.length) {
+    return { changed: false, content };
+  }
+
+  // Apply different fix strategies
+  switch (suggestion.type) {
+    case 'fix_timeout':
+      return insertTimeout(lines, lineIndex, suggestion.code);
+    case 'fix_import':
+      return insertImport(lines, suggestion.code);
+    case 'add_assertion':
+      return insertAssertion(lines, lineIndex, suggestion.code);
+    case 'update_expectation':
+      return updateLine(lines, lineIndex, suggestion.code);
+    default:
+      return insertCodeAtLine(lines, lineIndex, suggestion.code);
+  }
+}
+
+/**
+ * Insert timeout at test level
+ */
+function insertTimeout(lines: string[], lineIndex: number, code: string): { changed: boolean; content: string } {
+  // Find the test function and insert timeout after it
+  for (let i = lineIndex; i >= 0 && i >= lineIndex - 5; i--) {
+    if (lines[i].includes('it(') || lines[i].includes('test(')) {
+      lines[i] = lines[i].replace(/,?\s*\)\s*=>/, `, { timeout: 10000 } =>`);
+      return { changed: true, content: lines.join('\n') };
+    }
+  }
+  return { changed: false, content: lines.join('\n') };
+}
+
+/**
+ * Insert import at top of file
+ */
+function insertImport(lines: string[], code: string): { changed: boolean; content: string } {
+  // Find last import and insert after it
+  let lastImportIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith('import ')) {
+      lastImportIndex = i;
+    }
+  }
+
+  if (lastImportIndex >= 0) {
+    lines.splice(lastImportIndex + 1, 0, code);
+    return { changed: true, content: lines.join('\n') };
+  }
+
+  return { changed: false, content: lines.join('\n') };
+}
+
+/**
+ * Insert assertion in test
+ */
+function insertAssertion(lines: string[], lineIndex: number, code: string): { changed: boolean; content: string } {
+  // Insert before the closing brace
+  for (let i = lineIndex; i < Math.min(lines.length, lineIndex + 10); i++) {
+    if (lines[i].trim() === '});') {
+      lines.splice(i, 0, code);
+      return { changed: true, content: lines.join('\n') };
+    }
+  }
+  return { changed: false, content: lines.join('\n') };
+}
+
+/**
+ * Update a specific line
+ */
+function updateLine(lines: string[], lineIndex: number, code: string): { changed: boolean; content: string } {
+  if (lineIndex >= 0 && lineIndex < lines.length) {
+    lines[lineIndex] = code;
+    return { changed: true, content: lines.join('\n') };
+  }
+  return { changed: false, content: lines.join('\n') };
+}
+
+/**
+ * Insert code at specific line
+ */
+function insertCodeAtLine(lines: string[], lineIndex: number, code: string): { changed: boolean; content: string } {
+  lines.splice(lineIndex, 0, code);
+  return { changed: true, content: lines.join('\n') };
+}
+
+/**
+ * Create backup of a file
+ */
+async function createBackup(filePath: string, backupDir?: string): Promise<string> {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupFileName = `${filePath}.backup-${timestamp}`;
+
+  if (backupDir) {
+    if (!existsSync(backupDir)) {
+      mkdirSync(backupDir, { recursive: true });
+    }
+    const backupPath = join(backupDir, basename(filePath));
+    await writeFile(backupPath, await readFile(filePath, 'utf-8'));
+    return backupPath;
+  }
+
+  await writeFile(backupFileName, await readFile(filePath, 'utf-8'));
+  return backupFileName;
+}
+
+/**
+ * Generate unified diff format
+ */
+export function generateDiff(original: string, modified: string): string {
+  const origLines = original.split('\n');
+  const modLines = modified.split('\n');
+
+  const diff: string[] = [];
+  let i = 0;
+  let j = 0;
+
+  while (i < origLines.length || j < modLines.length) {
+    if (i < origLines.length && j < modLines.length && origLines[i] === modLines[j]) {
+      i++;
+      j++;
+    } else {
+      if (i < origLines.length) {
+        diff.push(`- ${origLines[i]}`);
+        i++;
+      }
+      if (j < modLines.length) {
+        diff.push(`+ ${modLines[j]}`);
+        j++;
+      }
+    }
+  }
+
+  return diff.join('\n');
+}
+
+/**
+ * Revert changes from backup
+ */
+export async function revertBackup(backupPath: string, originalPath: string): Promise<boolean> {
+  try {
+    const content = await readFile(backupPath, 'utf-8');
+    await writeFile(originalPath, content, 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}