added file tree & fixed error logs

Author: Gerome-Elassaad

app/api/ai/analyze-code/route.ts

@@ -1,11 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { supabase } from '@/lib/supabase'
 
 interface CodeAnalysisRequest {
   code: string
   language: string
   file: string
   cursorPosition: { line: number; column: number }
+  model: any // LLMModel
+  config: any
 }
 
 interface CodeSuggestion {
@@ -30,6 +31,7 @@ interface Diagnostic {
 
 export async function POST(request: NextRequest) {
   try {
+    const supabase = require('@/lib/supabase').supabase
     const authHeader = request.headers.get('authorization')
     if (!authHeader) {
       return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
@@ -42,14 +44,14 @@ export async function POST(request: NextRequest) {
     }
 
     const body: CodeAnalysisRequest = await request.json()
-    const { code, language, file, cursorPosition } = body
+    const { code, language, file, cursorPosition, model, config } = body
 
-    if (!code || !language) {
+    if (!code || !language || !model || !config) {
       return NextResponse.json({ error: 'Missing required fields' }, { status: 400 })
     }
 
     // Analyze code using AI
-    const analysis = await analyzeCodeWithAI(code, language, file, cursorPosition)
+    const analysis = await analyzeCodeWithAI(code, language, file, cursorPosition, model, config)
 
     return NextResponse.json({
       suggestions: analysis.suggestions,
@@ -70,109 +72,44 @@ async function analyzeCodeWithAI(
   code: string,
   language: string,
   file: string,
-  cursorPosition: { line: number; column: number }
+  cursorPosition: { line: number; column: number },
+  model: any, // LLMModel
+  config: any // LLMModelConfig
 ): Promise<{
   suggestions: CodeSuggestion[]
   diagnostics: Diagnostic[]
   metrics: any
 }> {
-  // Get OpenAI API key from environment
-  const apiKey = process.env.OPENAI_API_KEY
-  if (!apiKey) {
-    throw new Error('OpenAI API key not configured')
-  }
-
   const lines = code.split('\n')
   const currentLine = lines[cursorPosition.line - 1] || ''
-  const context = lines.slice(Math.max(0, cursorPosition.line - 5), cursorPosition.line + 5).join('\n')
 
   try {
-    const response = await fetch('https://api.openai.com/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        model: 'gpt-4',
-        messages: [
-          {
-            role: 'system',
-            content: `You are an expert code analyst and assistant. Analyze the provided ${language} code and provide:
-
-1. **Code Suggestions**: Improvements, optimizations, refactoring opportunities
-2. **Diagnostics**: Potential errors, warnings, and issues
-3. **Best Practices**: Adherence to ${language} conventions and patterns
-
-Focus on:
-- Performance optimizations
-- Code quality improvements
-- Security vulnerabilities
-- Best practice violations
-- Type safety (for TypeScript)
-- Modern syntax usage
-- Error handling improvements
-
-Return your analysis as JSON in this exact format:
-{
-  "suggestions": [
-    {
-      "id": "unique-id",
-      "type": "completion|refactor|fix|optimize",
-      "line": number,
-      "column": number,
-      "text": "original text",
-      "replacement": "suggested replacement",
-      "confidence": 0.0-1.0,
-      "description": "brief description"
-    }
-  ],
-  "diagnostics": [
-    {
-      "id": "unique-id",
-      "type": "error|warning|info",
-      "line": number,
-      "column": number,
-      "message": "diagnostic message",
-      "suggestion": "optional fix suggestion"
-    }
-  ]
-}`
-          },
-          {
-            role: 'user',
-            content: `Analyze this ${language} code from file "${file}":
-
-\`\`\`${language}
-${code}
-\`\`\`
-
-Current cursor position: Line ${cursorPosition.line}, Column ${cursorPosition.column}
-Current line context: "${currentLine}"
-
-Provide analysis focusing on the area around the cursor and overall code quality.`
-          }
-        ],
-        temperature: 0.3,
-        max_tokens: 2000,
-      }),
+    const { E2BToolClient, E2BToolType } = require('@/lib/e2b/toolClient')
+    const e2bToolClient = new E2BToolClient()
+
+    const result = await e2bToolClient.execute({
+      toolType: 'new_task' as any, //E2BToolType,
+      userInput: `Analyze this ${language} code from file "${file}":\n\`\`\`${language}\n${code}\n\`\`\`\nCurrent cursor position: Line ${cursorPosition.line}, Column ${cursorPosition.column}\nCurrent line context: "${currentLine}"\n\nProvide analysis focusing on the area around the cursor and overall code quality.`,
+      model: model,
+      config: config,
+      userID: 'user-id', // Replace with actual user ID
+      teamID: 'team-id', // Replace with actual team ID
     })
 
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.statusText}`)
+    if (!result.success) {
+      throw new Error(result.executionResult.toolResponse || 'Code analysis failed')
     }
 
-    const result = await response.json()
-    const analysisText = result.choices[0]?.message?.content
+    const analysisText = result.executionResult.aiResponse
 
     if (!analysisText) {
-      throw new Error('No analysis returned from OpenAI')
+      throw new Error('No analysis returned from AI')
     }
 
     // Parse the JSON response
     try {
       const analysis = JSON.parse(analysisText)
-      
+
       // Add IDs if missing
       analysis.suggestions = analysis.suggestions?.map((s: any, i: number) => ({
         ...s,
@@ -236,4 +173,4 @@ function calculateComplexity(code: string): number {
   }
 
   return complexity
-}
+}

app/api/ai/generate-file/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+
+const projectRoot = process.cwd();
+
+export async function POST(request: NextRequest) {
+  try {
+    const { path: newPath, prompt } = await request.json();
+    const fullPath = path.join(projectRoot, newPath);
+
+    // This is where you would call your AI model to generate the file content
+    // For now, we'll just use the prompt as the content
+    const content = `// content for ${newPath}\n\n${prompt}`;
+
+    fs.writeFileSync(fullPath, content);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Failed to generate file:', error);
+    return NextResponse.json(
+      { error: 'Failed to generate file' },
+      { status: 500 }
+    );
+  }
+}

app/api/file-system/route.ts

@@ -0,0 +1,115 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+
+type FileSystemNode = {
+  id: string;
+  name: string;
+  type: 'file' | 'folder';
+  path: string;
+  children?: FileSystemNode[];
+};
+
+const projectRoot = process.cwd();
+
+function getFileTree(dir: string): FileSystemNode[] {
+  const dirents = fs.readdirSync(dir, { withFileTypes: true });
+  const tree: FileSystemNode[] = [];
+
+  for (const dirent of dirents) {
+    const fullPath = path.join(dir, dirent.name);
+    const id = path.relative(projectRoot, fullPath);
+
+    if (dirent.isDirectory()) {
+      tree.push({
+        id,
+        name: dirent.name,
+        type: 'folder',
+        path: id,
+        children: getFileTree(fullPath),
+      });
+    } else {
+      tree.push({
+        id,
+        name: dirent.name,
+        type: 'file',
+        path: id,
+      });
+    }
+  }
+  return tree;
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const fileTree = getFileTree(projectRoot);
+    return NextResponse.json(fileTree);
+  } catch (error) {
+    console.error('Failed to read file tree:', error);
+    return NextResponse.json(
+      { error: 'Failed to read file tree' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const { path: newPath, type } = await request.json();
+    const fullPath = path.join(projectRoot, newPath);
+
+    if (type === 'folder') {
+      fs.mkdirSync(fullPath, { recursive: true });
+    } else {
+      fs.writeFileSync(fullPath, '');
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Failed to create file/folder:', error);
+    return NextResponse.json(
+      { error: 'Failed to create file/folder' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const { oldPath, newPath } = await request.json();
+    const fullOldPath = path.join(projectRoot, oldPath);
+    const fullNewPath = path.join(projectRoot, newPath);
+
+    fs.renameSync(fullOldPath, fullNewPath);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Failed to rename file/folder:', error);
+    return NextResponse.json(
+      { error: 'Failed to rename file/folder' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    const { path: deletePath } = await request.json();
+    const fullPath = path.join(projectRoot, deletePath);
+
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      fs.rmdirSync(fullPath, { recursive: true });
+    } else {
+      fs.unlinkSync(fullPath);
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Failed to delete file/folder:', error);
+    return NextResponse.json(
+      { error: 'Failed to delete file/folder' },
+      { status: 500 }
+    );
+  }
+}

app/api/sandbox/route.ts

@@ -201,25 +201,30 @@ export async function POST(req: Request) {
 
 function validateSandboxRequest(request: any): { valid: boolean; error?: string; code?: string } {
   if (!request.fragment) {
+    console.error("Validation failed: Fragment is required", { code: "MISSING_FRAGMENT" }); // Added logging
     return { valid: false, error: "Fragment is required", code: "MISSING_FRAGMENT" }
   }
 
   if (!request.userID || typeof request.userID !== 'string') {
+    console.error("Validation failed: Valid user ID is required", { code: "MISSING_USER_ID", userID: request.userID }); // Added logging
     return { valid: false, error: "Valid user ID is required", code: "MISSING_USER_ID" }
   }
 
   if (!request.teamID || typeof request.teamID !== 'string') {
+    console.error("Validation failed: Valid team ID is required", { code: "MISSING_TEAM_ID", teamID: request.teamID }); // Added logging
     return { valid: false, error: "Valid team ID is required", code: "MISSING_TEAM_ID" }
   }
 
   const { fragment } = request
 
   if (!fragment.template || typeof fragment.template !== 'string') {
+    console.error("Validation failed: Valid template is required", { code: "INVALID_TEMPLATE", template: fragment.template }); // Added logging
     return { valid: false, error: "Valid template is required", code: "INVALID_TEMPLATE" }
   }
 
 
   if (!Object.keys(templatesData).includes(fragment.template)) {
+    console.error("Validation failed: Unknown template", { code: "UNKNOWN_TEMPLATE", template: fragment.template, allowedTemplates: Object.keys(templatesData) }); // Added logging
     return { valid: false, error: `Template '${fragment.template}' is not a valid template.`, code: "UNKNOWN_TEMPLATE" }
   }
 
@@ -228,9 +233,11 @@ function validateSandboxRequest(request: any): { valid: boolean; error?: string;
     for (let i = 0; i < fragment.files.length; i++) {
       const file = fragment.files[i]
       if (!file.file_path || typeof file.file_path !== 'string') {
+        console.error("Validation failed: File missing or invalid file path", { code: "INVALID_FILE_PATH", fileIndex: i, filePath: file.file_path }); // Added logging
         return { valid: false, error: `File ${i}: Missing or invalid file path`, code: "INVALID_FILE_PATH" }
       }
       if (typeof file.file_content !== 'string') {
+        console.error("Validation failed: File content must be a string", { code: "INVALID_FILE_CONTENT", fileIndex: i }); // Added logging
         return { valid: false, error: `File ${i}: File content must be a string`, code: "INVALID_FILE_CONTENT" }
       }
     }