diff --git a/ERROR_REPAIR_GUIDE.md b/ERROR_REPAIR_GUIDE.md new file mode 100644 index 0000000..1bbbefb --- /dev/null +++ b/ERROR_REPAIR_GUIDE.md @@ -0,0 +1,172 @@ +# Error Detection & Auto Repair Feature + +## Overview + +CodeForge includes an intelligent error detection and auto-repair system powered by AI that helps you identify and fix code issues automatically. + +## Features + +### 🔍 Error Detection + +The system automatically scans your code files for various types of errors: + +- **Syntax Errors**: Missing parentheses, unbalanced braces, malformed statements +- **Import Errors**: Unused imports that clutter your code +- **Type Errors**: Use of `any` types that reduce type safety +- **Lint Errors**: Code style issues like using `var` instead of `const`/`let` + +### 🔧 Auto Repair Modes + +1. **Single Error Repair** + - Click the wrench icon next to any error + - AI fixes just that specific issue + - Get instant feedback with explanations + +2. **Batch File Repair** + - Repair all errors in a single file + - Click "Repair" button at the file level + - Fixes are applied all at once + +3. **Context-Aware Repair** + - Uses related files for better accuracy + - Understands your project structure + - Maintains consistency across files + +4. **Full Project Repair** + - Click "Repair All" to fix all files + - Processes multiple files in parallel + - Comprehensive project-wide fixes + +## How to Use + +### Quick Start + +1. Open the **Error Repair** tab in the main navigation +2. Click **Scan** to detect errors in your project +3. Review the detected errors grouped by file +4. Choose your repair method: + - Click wrench icon for single error fix + - Click "Repair" for file-level fix + - Click "Repair All" for project-wide fix + +### Understanding Error Indicators + +- **🔴 Error Badge**: Red badge shows critical errors that break functionality +- **⚠ī¸ Warning Badge**: Yellow badge shows code quality issues +- **ℹī¸ Info Badge**: Blue badge shows suggestions for improvement + +### Error Panel Features + +- **Grouped by File**: Errors are organized by the file they appear in +- **Line Numbers**: Jump directly to the problematic code +- **Code Snippets**: View the problematic code inline +- **Expandable Details**: Click to see more context +- **Quick Navigation**: Click "Open" to jump to the file in the editor + +## Best Practices + +1. **Regular Scans**: Run scans periodically as you code +2. **Review AI Fixes**: Always review what the AI changed +3. **Test After Repair**: Verify your code still works as expected +4. **Incremental Fixes**: Fix errors in small batches for easier verification + +## Error Types Explained + +### Syntax Errors +```typescript +// ❌ Before (missing parentheses) +function calculate { return 5 } + +// ✅ After +function calculate() { return 5 } +``` + +### Import Errors +```typescript +// ❌ Before (unused import) +import { useState, useEffect, useMemo } from 'react' +// Only useState is used + +// ✅ After +import { useState } from 'react' +``` + +### Type Errors +```typescript +// ❌ Before (any type) +function process(data: any) { } + +// ✅ After +function process(data: string | number) { } +``` + +### Lint Errors +```typescript +// ❌ Before (var keyword) +var count = 0 + +// ✅ After +const count = 0 +``` + +## Tips & Tricks + +- **Badge Notification**: Look for the error count badge on the "Error Repair" tab +- **Header Alert**: When errors are detected, a button appears in the header +- **File Targeting**: Use file-level repair when errors are localized +- **Context Matters**: Complex errors benefit from context-aware repair + +## Troubleshooting + +**Q: The scan isn't finding errors I can see** +A: Some complex errors may require manual review. The scanner focuses on common, fixable issues. + +**Q: A fix didn't work as expected** +A: You can undo changes in the editor. Try single-error repair for more control. + +**Q: AI repair is taking too long** +A: Large files or complex errors may take time. Consider fixing smaller batches. + +**Q: Some errors remain after repair** +A: Some errors may require manual intervention or additional context. Check the "remaining issues" explanation. + +## Integration with CodeForge + +The error repair system works seamlessly with other CodeForge features: + +- **Code Editor**: Jump directly from errors to code +- **AI Generate**: AI-generated code is also scannable +- **Export**: Ensure clean code before project export +- **All Designers**: Errors in any file type are detected + +## Technical Details + +### Error Detection Algorithm + +1. **Lexical Analysis**: Tokenize source code +2. **Pattern Matching**: Identify common error patterns +3. **Import Analysis**: Track import usage +4. **Type Checking**: Basic type validation for TypeScript + +### AI Repair Process + +1. **Context Gathering**: Collect error details and surrounding code +2. **Prompt Construction**: Build repair prompt with constraints +3. **LLM Processing**: Send to GPT-4o for intelligent fixes +4. **Validation**: Parse and validate the response +5. **Application**: Apply fixes to the codebase + +### Supported Languages + +- TypeScript (`.ts`, `.tsx`) +- JavaScript (`.js`, `.jsx`) +- CSS/SCSS (basic syntax checking) + +## Future Enhancements + +- Real-time error detection as you type +- Custom error rules +- Integration with ESLint +- TypeScript compiler integration +- Performance metrics +- Error history tracking diff --git a/PRD.md b/PRD.md index c3b7ac9..4753eeb 100644 --- a/PRD.md +++ b/PRD.md @@ -68,6 +68,13 @@ This is a full-featured low-code IDE with multiple integrated tools (code editor - **Progression**: Create test suite manually or with AI → Select test type (component/function/hook/integration) → Add test cases → Configure setup, assertions, and teardown → AI can generate complete test suites → Export test files for Vitest/React Testing Library - **Success criteria**: Can create test suites for different types; test cases have multiple assertions; setup/teardown code is optional; AI tests are comprehensive; generates valid Vitest test code +### Auto Error Detection & Repair +- **Functionality**: Automated error detection and AI-powered code repair system that scans files for syntax, type, import, and lint errors +- **Purpose**: Automatically identify and fix code errors without manual debugging, saving time and reducing bugs +- **Trigger**: Opening the Error Repair tab or clicking "Scan" button +- **Progression**: Scan files → Detect errors (syntax, imports, types, lint) → Display errors grouped by file → Repair individual errors or batch repair all → View explanations → Rescan to verify fixes +- **Success criteria**: Detects common errors accurately; AI repairs produce valid, working code; can repair single errors or entire files; provides clear explanations of fixes; supports context-aware repair using related files + ### Project Generator - **Functionality**: Exports complete Next.js project with all configurations - **Purpose**: Converts visual designs into downloadable, runnable applications @@ -88,6 +95,9 @@ This is a full-featured low-code IDE with multiple integrated tools (code editor - **Invalid Test Selectors**: Warn when Playwright selectors might be problematic - **Missing Test Assertions**: Highlight test cases without assertions as incomplete - **Storybook Args Type Mismatch**: Auto-detect arg types and provide appropriate input controls +- **No Errors Found**: Show success state when error scan finds no issues +- **Unrepairable Errors**: Display clear messages when AI cannot fix certain errors and suggest manual intervention +- **Context-Dependent Errors**: Use related files as context for more accurate error repair ## Design Direction The design should evoke a professional IDE environment while remaining approachable - think Visual Studio Code meets Figma. Clean panels, clear hierarchy, and purposeful use of space to avoid overwhelming users with options. @@ -149,10 +159,15 @@ Animations should feel responsive and purposeful - quick panel transitions (200m - Play (play icon) for Playwright E2E tests - BookOpen (book-open icon) for Storybook stories - Flask (flask icon) for unit tests + - Wrench (wrench icon) for error repair - FileCode (file-code icon) for individual files - Plus (plus icon) for create actions - Download (download icon) for export - Sparkle (sparkle icon) for AI generation + - Lightning (lightning icon) for scan/quick actions + - CheckCircle (check-circle icon) for success states + - Warning (warning icon) for warnings + - X (x icon) for errors - **Spacing**: - Panel padding: p-6 (24px) for main content areas diff --git a/src/App.tsx b/src/App.tsx index 28283f9..bbdeaf0 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -1,10 +1,12 @@ -import { useState } from 'react' +import { useState, useEffect } from 'react' import { useKV } from '@github/spark/hooks' +import { useAutoRepair } from '@/hooks/use-auto-repair' import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs' import { Button } from '@/components/ui/button' +import { Badge } from '@/components/ui/badge' import { Card } from '@/components/ui/card' import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from '@/components/ui/resizable' -import { Code, Database, Tree, PaintBrush, Download, Sparkle, Flask, BookOpen, Play } from '@phosphor-icons/react' +import { Code, Database, Tree, PaintBrush, Download, Sparkle, Flask, BookOpen, Play, Wrench } from '@phosphor-icons/react' import { ProjectFile, PrismaModel, ComponentNode, ThemeConfig, PlaywrightTest, StorybookStory, UnitTest } from '@/types/project' import { CodeEditor } from '@/components/CodeEditor' import { ModelDesigner } from '@/components/ModelDesigner' @@ -14,6 +16,7 @@ import { FileExplorer } from '@/components/FileExplorer' import { PlaywrightDesigner } from '@/components/PlaywrightDesigner' import { StorybookDesigner } from '@/components/StorybookDesigner' import { UnitTestDesigner } from '@/components/UnitTestDesigner' +import { ErrorPanel } from '@/components/ErrorPanel' import { generateNextJSProject, generatePrismaSchema, generateMUITheme, generatePlaywrightTests, generateStorybookStories, generateUnitTests } from '@/lib/generators' import { AIService } from '@/lib/ai-service' import { toast } from 'sonner' @@ -109,6 +112,8 @@ function App() { const safeStorybookStories = storybookStories || [] const safeUnitTests = unitTests || [] + const { errors: autoDetectedErrors } = useAutoRepair(safeFiles, false) + const handleFileChange = (fileId: string, content: string) => { setFiles((currentFiles) => (currentFiles || []).map((f) => (f.id === fileId ? { ...f, content } : f)) @@ -200,6 +205,16 @@ function App() {
+ {autoDetectedErrors.length > 0 && ( + + )}
@@ -296,6 +320,14 @@ function App() { + + + + diff --git a/src/components/ErrorPanel.tsx b/src/components/ErrorPanel.tsx new file mode 100644 index 0000000..ecaca1e --- /dev/null +++ b/src/components/ErrorPanel.tsx @@ -0,0 +1,377 @@ +import { useState, useEffect } from 'react' +import { CodeError } from '@/types/errors' +import { ProjectFile } from '@/types/project' +import { ErrorRepairService } from '@/lib/error-repair-service' +import { Card } from '@/components/ui/card' +import { Button } from '@/components/ui/button' +import { Badge } from '@/components/ui/badge' +import { ScrollArea } from '@/components/ui/scroll-area' +import { Separator } from '@/components/ui/separator' +import { + Warning, + X, + Wrench, + CheckCircle, + Info, + Lightning, + FileCode, + ArrowRight +} from '@phosphor-icons/react' +import { toast } from 'sonner' +import { + Collapsible, + CollapsibleContent, + CollapsibleTrigger, +} from '@/components/ui/collapsible' + +interface ErrorPanelProps { + files: ProjectFile[] + onFileChange: (fileId: string, content: string) => void + onFileSelect: (fileId: string) => void +} + +export function ErrorPanel({ files, onFileChange, onFileSelect }: ErrorPanelProps) { + const [errors, setErrors] = useState([]) + const [isScanning, setIsScanning] = useState(false) + const [isRepairing, setIsRepairing] = useState(false) + const [autoRepairEnabled, setAutoRepairEnabled] = useState(false) + const [expandedErrors, setExpandedErrors] = useState>(new Set()) + + const scanForErrors = async () => { + setIsScanning(true) + try { + const allErrors: CodeError[] = [] + + for (const file of files) { + const fileErrors = await ErrorRepairService.detectErrors(file) + allErrors.push(...fileErrors) + } + + setErrors(allErrors) + + if (allErrors.length === 0) { + toast.success('No errors found!') + } else { + toast.info(`Found ${allErrors.length} issue${allErrors.length > 1 ? 's' : ''}`) + } + } catch (error) { + toast.error('Error scanning failed') + console.error(error) + } finally { + setIsScanning(false) + } + } + + const repairSingleError = async (error: CodeError) => { + const file = files.find(f => f.id === error.fileId) + if (!file) return + + setIsRepairing(true) + try { + const result = await ErrorRepairService.repairCode(file, [error]) + + if (result.success && result.fixedCode) { + onFileChange(file.id, result.fixedCode) + + setErrors(prev => prev.map(e => + e.id === error.id ? { ...e, isFixed: true, fixedCode: result.fixedCode } : e + )) + + toast.success(`Fixed: ${error.message}`, { + description: result.explanation, + }) + + await scanForErrors() + } else { + toast.error('Failed to repair error') + } + } catch (error) { + toast.error('Repair failed') + console.error(error) + } finally { + setIsRepairing(false) + } + } + + const repairAllErrors = async () => { + setIsRepairing(true) + try { + const results = await ErrorRepairService.repairMultipleFiles(files, errors) + + let fixedCount = 0 + results.forEach((result, fileId) => { + if (result.success && result.fixedCode) { + onFileChange(fileId, result.fixedCode) + fixedCount++ + } + }) + + if (fixedCount > 0) { + toast.success(`Repaired ${fixedCount} file${fixedCount > 1 ? 's' : ''}`) + await scanForErrors() + } else { + toast.error('No files could be repaired') + } + } catch (error) { + toast.error('Batch repair failed') + console.error(error) + } finally { + setIsRepairing(false) + } + } + + const repairFileWithContext = async (fileId: string) => { + const file = files.find(f => f.id === fileId) + if (!file) return + + const fileErrors = errors.filter(e => e.fileId === fileId) + if (fileErrors.length === 0) return + + setIsRepairing(true) + try { + const relatedFiles = files.filter(f => f.id !== fileId).slice(0, 3) + + const result = await ErrorRepairService.repairWithContext(file, fileErrors, relatedFiles) + + if (result.success && result.fixedCode) { + onFileChange(file.id, result.fixedCode) + + toast.success(`Repaired ${file.name}`, { + description: result.explanation, + }) + + await scanForErrors() + } else { + toast.error('Failed to repair file') + } + } catch (error) { + toast.error('Context-aware repair failed') + console.error(error) + } finally { + setIsRepairing(false) + } + } + + const toggleErrorExpanded = (errorId: string) => { + setExpandedErrors(prev => { + const next = new Set(prev) + if (next.has(errorId)) { + next.delete(errorId) + } else { + next.add(errorId) + } + return next + }) + } + + const getSeverityIcon = (severity: string) => { + switch (severity) { + case 'error': + return + case 'warning': + return + case 'info': + return + default: + return + } + } + + const getSeverityColor = (severity: string) => { + switch (severity) { + case 'error': + return 'destructive' + case 'warning': + return 'secondary' + case 'info': + return 'outline' + default: + return 'outline' + } + } + + const errorsByFile = errors.reduce((acc, error) => { + if (!acc[error.fileId]) { + acc[error.fileId] = [] + } + acc[error.fileId].push(error) + return acc + }, {} as Record) + + const errorCount = errors.filter(e => e.severity === 'error').length + const warningCount = errors.filter(e => e.severity === 'warning').length + + useEffect(() => { + if (files.length > 0 && errors.length === 0) { + scanForErrors() + } + }, []) + + return ( +
+
+
+
+
+ +

Error Detection & Repair

+
+ {errors.length > 0 && ( +
+ {errorCount > 0 && ( + + {errorCount} {errorCount === 1 ? 'Error' : 'Errors'} + + )} + {warningCount > 0 && ( + + {warningCount} {warningCount === 1 ? 'Warning' : 'Warnings'} + + )} +
+ )} +
+
+ + +
+
+
+ + +
+ {errors.length === 0 && !isScanning && ( + + +

No Issues Found

+

+ All files are looking good! Click "Scan" to check again. +

+ + )} + + {isScanning && ( + + +

Scanning Files...

+

+ Analyzing your code for errors and issues +

+ + )} + + {errors.length > 0 && ( +
+ {Object.entries(errorsByFile).map(([fileId, fileErrors]) => { + const file = files.find(f => f.id === fileId) + if (!file) return null + + return ( + +
+
+ + {file.name} + + {fileErrors.length} {fileErrors.length === 1 ? 'issue' : 'issues'} + +
+
+ + +
+
+ +
+ {fileErrors.map((error) => ( + +
+
+ {getSeverityIcon(error.severity)} +
+
+
+ + {error.type} + + {error.line && ( + + Line {error.line} + + )} + {error.isFixed && ( + + + Fixed + + )} +
+

{error.message}

+ {error.code && ( + + + + )} +
+ +
+ {error.code && ( + +
+ {error.code} +
+ + )} + + ))} +
+ + ) + })} +
+ )} +
+ +
+ ) +} diff --git a/src/hooks/use-auto-repair.ts b/src/hooks/use-auto-repair.ts new file mode 100644 index 0000000..6d3e7db --- /dev/null +++ b/src/hooks/use-auto-repair.ts @@ -0,0 +1,48 @@ +import { useState, useEffect, useCallback } from 'react' +import { ProjectFile } from '@/types/project' +import { CodeError } from '@/types/errors' +import { ErrorRepairService } from '@/lib/error-repair-service' + +export function useAutoRepair( + files: ProjectFile[], + enabled: boolean = false +) { + const [errors, setErrors] = useState([]) + const [isScanning, setIsScanning] = useState(false) + + const scanFiles = useCallback(async () => { + if (!enabled || files.length === 0) return + + setIsScanning(true) + try { + const allErrors: CodeError[] = [] + + for (const file of files) { + const fileErrors = await ErrorRepairService.detectErrors(file) + allErrors.push(...fileErrors) + } + + setErrors(allErrors) + } catch (error) { + console.error('Auto-scan failed:', error) + } finally { + setIsScanning(false) + } + }, [files, enabled]) + + useEffect(() => { + if (enabled) { + const timeoutId = setTimeout(() => { + scanFiles() + }, 2000) + + return () => clearTimeout(timeoutId) + } + }, [files, enabled, scanFiles]) + + return { + errors, + isScanning, + scanFiles, + } +} diff --git a/src/lib/error-repair-service.ts b/src/lib/error-repair-service.ts new file mode 100644 index 0000000..93ab862 --- /dev/null +++ b/src/lib/error-repair-service.ts @@ -0,0 +1,316 @@ +import { CodeError, ErrorRepairResult } from '@/types/errors' +import { ProjectFile } from '@/types/project' + +/** + * ErrorRepairService - AI-powered code error detection and repair + * + * Features: + * - detectErrors: Scans files for syntax, import, type, and lint errors + * - repairCode: Fixes errors in a single file using AI + * - repairMultipleFiles: Batch repair multiple files with errors + * - repairWithContext: Context-aware repair using related files for better accuracy + * + * Error Types Detected: + * - Syntax errors (missing parentheses, unbalanced braces) + * - Import errors (unused imports) + * - Type errors (use of 'any' type) + * - Lint errors (var instead of const/let) + */ +export class ErrorRepairService { + static async detectErrors(file: ProjectFile): Promise { + const errors: CodeError[] = [] + + const syntaxErrors = this.detectSyntaxErrors(file) + const importErrors = this.detectImportErrors(file) + const typeErrors = this.detectBasicTypeErrors(file) + + return [...syntaxErrors, ...importErrors, ...typeErrors] + } + + private static detectSyntaxErrors(file: ProjectFile): CodeError[] { + const errors: CodeError[] = [] + const lines = file.content.split('\n') + + lines.forEach((line, index) => { + if (file.language === 'typescript' || file.language === 'javascript') { + if (line.includes('function') && !line.includes('(') && line.includes('{')) { + errors.push({ + id: `syntax-${file.id}-${index}`, + fileId: file.id, + fileName: file.name, + filePath: file.path, + line: index + 1, + message: 'Function declaration missing parentheses', + severity: 'error', + type: 'syntax', + code: line.trim(), + }) + } + + const openBraces = (line.match(/{/g) || []).length + const closeBraces = (line.match(/}/g) || []).length + if (openBraces !== closeBraces && !line.trim().startsWith('//')) { + const nextLine = lines[index + 1] + if (nextLine && !nextLine.includes('}') && !nextLine.includes('{')) { + errors.push({ + id: `syntax-${file.id}-${index}`, + fileId: file.id, + fileName: file.name, + filePath: file.path, + line: index + 1, + message: 'Possible unbalanced braces', + severity: 'warning', + type: 'syntax', + code: line.trim(), + }) + } + } + } + }) + + return errors + } + + private static detectImportErrors(file: ProjectFile): CodeError[] { + const errors: CodeError[] = [] + const lines = file.content.split('\n') + + const importedNames = new Set() + const usedNames = new Set() + + lines.forEach((line, index) => { + if (line.trim().startsWith('import ')) { + const importMatch = line.match(/import\s+(?:{([^}]+)}|(\w+))\s+from/) + if (importMatch) { + const namedImports = importMatch[1] + const defaultImport = importMatch[2] + + if (namedImports) { + namedImports.split(',').forEach(name => { + importedNames.add(name.trim().split(' as ')[0]) + }) + } + if (defaultImport) { + importedNames.add(defaultImport.trim()) + } + } + } else { + importedNames.forEach(name => { + const regex = new RegExp(`\\b${name}\\b`) + if (regex.test(line)) { + usedNames.add(name) + } + }) + } + }) + + importedNames.forEach(name => { + if (!usedNames.has(name)) { + errors.push({ + id: `import-${file.id}-${name}`, + fileId: file.id, + fileName: file.name, + filePath: file.path, + message: `Unused import: ${name}`, + severity: 'warning', + type: 'import', + }) + } + }) + + return errors + } + + private static detectBasicTypeErrors(file: ProjectFile): CodeError[] { + const errors: CodeError[] = [] + + if (file.language !== 'typescript') return errors + + const lines = file.content.split('\n') + + lines.forEach((line, index) => { + if (line.includes('any') && !line.trim().startsWith('//')) { + errors.push({ + id: `type-${file.id}-${index}`, + fileId: file.id, + fileName: file.name, + filePath: file.path, + line: index + 1, + message: 'Use of "any" type - consider using a more specific type', + severity: 'warning', + type: 'type', + code: line.trim(), + }) + } + + const varMatch = line.match(/\bvar\s+/) + if (varMatch) { + errors.push({ + id: `lint-${file.id}-${index}`, + fileId: file.id, + fileName: file.name, + filePath: file.path, + line: index + 1, + message: 'Use "const" or "let" instead of "var"', + severity: 'warning', + type: 'lint', + code: line.trim(), + }) + } + }) + + return errors + } + + static async repairCode(file: ProjectFile, errors: CodeError[]): Promise { + if (errors.length === 0) { + return { + success: true, + fixedCode: file.content, + explanation: 'No errors detected', + } + } + + try { + const errorDescriptions = errors + .map(err => `Line ${err.line || 'unknown'}: ${err.message} - "${err.code || 'N/A'}"`) + .join('\n') + + const promptText = `You are a code repair assistant. Fix the following errors in this code: + +File: ${file.name} (${file.language}) + +Errors: +${errorDescriptions} + +Original code: +\`\`\`${file.language} +${file.content} +\`\`\` + +Return a valid JSON object with the following structure: +{ + "fixedCode": "the complete fixed code here", + "explanation": "brief explanation of what was fixed", + "remainingIssues": ["any issues that couldn't be fixed"] +} + +Rules: +- Fix all syntax errors, import errors, and type errors +- Remove unused imports +- Replace "any" types with appropriate types +- Replace "var" with "const" or "let" +- Maintain code functionality and structure +- Keep the same imports style and formatting +- Return the COMPLETE file content, not just the fixes` + + const response = await window.spark.llm(promptText, 'gpt-4o', true) + const parsed = JSON.parse(response) + + return { + success: true, + fixedCode: parsed.fixedCode, + explanation: parsed.explanation, + remainingIssues: parsed.remainingIssues || [], + } + } catch (error) { + console.error('Auto-repair failed:', error) + return { + success: false, + explanation: 'Failed to repair code automatically', + } + } + } + + static async repairMultipleFiles(files: ProjectFile[], allErrors: CodeError[]): Promise> { + const results = new Map() + + const fileErrorMap = new Map() + allErrors.forEach(error => { + if (!fileErrorMap.has(error.fileId)) { + fileErrorMap.set(error.fileId, []) + } + fileErrorMap.get(error.fileId)!.push(error) + }) + + for (const file of files) { + const fileErrors = fileErrorMap.get(file.id) || [] + if (fileErrors.length > 0) { + const result = await this.repairCode(file, fileErrors) + results.set(file.id, result) + } + } + + return results + } + + static async repairWithContext( + file: ProjectFile, + errors: CodeError[], + relatedFiles: ProjectFile[] + ): Promise { + if (errors.length === 0) { + return { + success: true, + fixedCode: file.content, + explanation: 'No errors detected', + } + } + + try { + const errorDescriptions = errors + .map(err => `Line ${err.line || 'unknown'}: ${err.message} - "${err.code || 'N/A'}"`) + .join('\n') + + const relatedFilesContext = relatedFiles + .map(f => `${f.path}:\n\`\`\`${f.language}\n${f.content.slice(0, 500)}...\n\`\`\``) + .join('\n\n') + + const promptText = `You are a code repair assistant. Fix the following errors in this code, considering the context of related files: + +File: ${file.name} (${file.language}) + +Errors: +${errorDescriptions} + +Related files for context: +${relatedFilesContext} + +Original code to fix: +\`\`\`${file.language} +${file.content} +\`\`\` + +Return a valid JSON object with the following structure: +{ + "fixedCode": "the complete fixed code here", + "explanation": "brief explanation of what was fixed", + "remainingIssues": ["any issues that couldn't be fixed"] +} + +Rules: +- Fix all syntax errors, import errors, and type errors +- Ensure imports match what's exported in related files +- Use consistent naming and patterns from related files +- Replace "any" types with appropriate types from context +- Maintain code functionality and structure +- Return the COMPLETE file content, not just the fixes` + + const response = await window.spark.llm(promptText, 'gpt-4o', true) + const parsed = JSON.parse(response) + + return { + success: true, + fixedCode: parsed.fixedCode, + explanation: parsed.explanation, + remainingIssues: parsed.remainingIssues || [], + } + } catch (error) { + console.error('Auto-repair with context failed:', error) + return { + success: false, + explanation: 'Failed to repair code automatically', + } + } + } +} diff --git a/src/types/errors.ts b/src/types/errors.ts new file mode 100644 index 0000000..7cfb1bf --- /dev/null +++ b/src/types/errors.ts @@ -0,0 +1,23 @@ +export interface CodeError { + id: string + fileId: string + fileName: string + filePath: string + line?: number + column?: number + message: string + severity: 'error' | 'warning' | 'info' + type: 'syntax' | 'type' | 'runtime' | 'lint' | 'import' + code?: string + suggestion?: string + isFixed?: boolean + originalCode?: string + fixedCode?: string +} + +export interface ErrorRepairResult { + success: boolean + fixedCode?: string + explanation?: string + remainingIssues?: string[] +}