refactor: Remove unnecessary console logs and improve error handling in project file and dependency loading

alightinastorm · alightinastorm · commit 68e352600e89 · 2025-07-20T01:12:52.000+02:00
diff --git a/src/services/typescript-project/dependency-loader.ts b/src/services/typescript-project/dependency-loader.ts
@@ -16,20 +16,17 @@ export class DependencyLoader {
    */
   static async loadProjectDependencyTypes(projectPath: string): Promise<void> {
     try {
-      console.log('Loading project dependency types...');
       
       // Parse package.json to get actual dependencies
       const packageJsonPath = `${projectPath}/package.json`;
       const packageJson = await TSConfigLoader.parsePackageJson(packageJsonPath);
       
       if (!packageJson) {
-        console.log('No package.json found, skipping dependency type loading');
         return;
       }
 
       // Get all dependencies
       const allDependencies = DependencyLoader.getAllDependencies(packageJson);
-      console.log(`Found ${Object.keys(allDependencies).length} dependencies to analyze for types`);
 
       // Process dependencies in batches to avoid overwhelming the system
       const batchSize = 10;
@@ -48,7 +45,6 @@ export class DependencyLoader {
         }
       }
 
-      console.log('Finished loading dependency types');
     } catch (error) {
       console.error('Error loading project dependency types:', error);
     }
@@ -81,7 +77,6 @@ export class DependencyLoader {
       // Check if the package exists
       const depPackageJson = await TSConfigLoader.parsePackageJson(`${depPath}/package.json`);
       if (!depPackageJson) {
-        console.log(`Package ${dependencyName} not found in node_modules`);
         return;
       }
 
@@ -105,7 +100,7 @@ export class DependencyLoader {
       }
 
     } catch (error) {
-      console.log(`Error loading types for ${dependencyName}:`, error);
+      // noop
     }
   }
 
@@ -129,7 +124,6 @@ export class DependencyLoader {
     packagePath: string, 
     packageJson: PackageJson
   ): Promise<void> {
-    console.log(`Loading framework types for ${packageName}`);
 
     // Load built-in types first
     await DependencyLoader.loadBuiltInTypes(packageName, packagePath, packageJson);
@@ -208,8 +202,6 @@ export class DependencyLoader {
         }
       }
 
-      console.log(`Loaded ${totalLoaded} Next.js type files`);
-
       // Also try to load @types/react if it exists (Next.js depends on React)
       await DependencyLoader.loadCorrespondingTypesPackage(projectPath, 'react');
       
@@ -257,7 +249,7 @@ export class DependencyLoader {
 
       // Try to load all entry points in parallel (truly parallel openFile)
       const loadPromises = typeEntryPoints.map((entryPoint) => {
-        const fullPath = entryPoint!.startsWith('/') ? 
+        const fullPath = entryPoint?.startsWith('/') ? 
           `${packagePath}${entryPoint}` : 
           `${packagePath}/${entryPoint}`;
 
@@ -268,7 +260,6 @@ export class DependencyLoader {
         const { content } = result;
         const virtualPath = `file:///node_modules/${packageName}/${entryPoint}`;
         monaco.languages.typescript.typescriptDefaults.addExtraLib(content, virtualPath);
-        console.log(`Loaded built-in types for ${packageName} from ${entryPoint}`);
         return true;
           })
           .catch(() => false);
@@ -375,10 +366,6 @@ export class DependencyLoader {
         }
       }
       
-      if (totalLoaded > 0) {
-        console.log(`Loaded ${totalLoaded} type files for ${packageName}`);
-      }
-      
     } catch (error) {
       console.warn(`Failed to search for type files in ${packagePath}:`, error);
     }
diff --git a/src/services/typescript-project/file-manager.ts b/src/services/typescript-project/file-manager.ts
@@ -19,16 +19,12 @@ export class FileManager {
       const includePatterns = tsConfig?.include || ['**/*'];
       const excludePatterns = tsConfig?.exclude || ['node_modules/**', 'dist/**', 'build/**', '**/*.min.js', '.git/**'];
 
-      console.log(`[FileManager] Searching for files with include: ${includePatterns} and exclude: ${excludePatterns}`);
-
       // Get all TypeScript/JavaScript files in the project based on tsconfig
       const files = await projectApi.searchFiles('**/*.{ts,tsx,js,jsx,d.ts}', projectPath, {
         includePatterns: includePatterns,
         excludePatterns: excludePatterns,
       });
 
-      console.log(`[FileManager] Found ${files.length} files matching tsconfig patterns.`);
-
       // Create a comprehensive file map for better import resolution
       const fileMap = new Map<string, string>();
       files.forEach(filePath => {
@@ -85,7 +81,6 @@ export class FileManager {
 
       await Promise.allSettled(loadPromises);
 
-      console.log(`[FileManager] Loaded ${projectFiles.size} files into Monaco with enhanced import mapping.`);
     } catch (error) {
       console.error('[FileManager] Error loading project files:', error);
     }
@@ -105,16 +100,12 @@ export class FileManager {
       const includePatterns = tsConfig?.include || ['**/*'];
       const excludePatterns = tsConfig?.exclude || ['node_modules/**', 'dist/**', 'build/**', '**/*.min.js', '.git/**'];
 
-      console.log(`[FileManager] Searching for files with include: ${includePatterns} and exclude: ${excludePatterns}`);
-
       // Get all TypeScript/JavaScript files in the project based on tsconfig
       const files = await projectApi.searchFiles('**/*.{ts,tsx,js,jsx,d.ts}', projectPath, {
         includePatterns: includePatterns,
         excludePatterns: excludePatterns,
       });
 
-      console.log(`[FileManager] Found ${files.length} files matching tsconfig patterns.`);
-
       // Prioritize loading files from common source directories
       const sourceFiles = files.filter(f =>
         f.includes('/src/') ||
@@ -143,7 +134,6 @@ export class FileManager {
 
       await Promise.allSettled(loadPromises);
 
-      console.log(`[FileManager] Loaded ${projectFiles.size} files into Monaco.`);
     } catch (error) {
       console.error('[FileManager] Error loading project files:', error);
     }
@@ -191,7 +181,6 @@ export class FileManager {
         // and 'javascript' for both .js and .jsx files
         const language = (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) ? 'typescript' : 'javascript';
         monaco.editor.createModel(content, language, uri);
-        console.log(`Created Monaco model for ${relativePath} with language ${language}`);
       } else {
         // Update existing model
         existingModel.setValue(content);
@@ -201,7 +190,6 @@ export class FileManager {
       if (filePath.endsWith('.d.ts')) {
         const virtualPath = `file:///${relativePath}`;
         monaco.languages.typescript.typescriptDefaults.addExtraLib(content, virtualPath);
-        console.log(`Added .d.ts file to extra libs: ${relativePath}`);
       }
 
     } catch (error) {
@@ -286,8 +274,6 @@ export class FileManager {
         excludePatterns: ['**/node_modules/**', '**/dist/**', '**/build/**', '.git/**']
       });
 
-      console.log(`Found ${projectTypeFiles.length} project type definition files`);
-
       // Load each project .d.ts file
       const loadPromises = projectTypeFiles.map(async (filePath) => {
         try {
@@ -300,7 +286,6 @@ export class FileManager {
           const virtualPath = `file:///${relativePath}`;
 
           monaco.languages.typescript.typescriptDefaults.addExtraLib(content, virtualPath);
-          console.log(`Loaded project type definitions from ${relativePath}`);
 
         } catch (error) {
           console.warn(`Failed to load project type file ${filePath}:`, error);
diff --git a/src/services/typescript-project/monaco-config.ts b/src/services/typescript-project/monaco-config.ts
@@ -88,23 +88,18 @@ export class MonacoConfig {
     // Properly configure baseUrl and paths for module resolution
     if (options.baseUrl) {
       monacoOptions.baseUrl = `${projectPath}${options.baseUrl.replace(/^\./, '')}`;
-      console.log(`[MonacoConfig] Set baseUrl to: ${monacoOptions.baseUrl}`);
     }
 
     if (options.paths) {
       monacoOptions.paths = {};
       for (const [key, value] of Object.entries(options.paths)) {
         monacoOptions.paths[key] = value.map(p => `${projectPath}${p.replace(/^\./, '')}`);
       }
-      console.log(`[MonacoConfig] Set paths to:`, monacoOptions.paths);
     }
 
     // Apply to both TypeScript and JavaScript defaults
     monaco.languages.typescript.typescriptDefaults.setCompilerOptions(monacoOptions);
     monaco.languages.typescript.javascriptDefaults.setCompilerOptions(monacoOptions);
-
-    console.log('Applied tsconfig compiler options to Monaco:', monacoOptions);
-    console.log('Original tsconfig options:', options);
   }
 
   /**
@@ -116,7 +111,6 @@ export class MonacoConfig {
       // so we need to reset the typescript defaults
       monaco.languages.typescript.typescriptDefaults.setExtraLibs([]);
       monaco.languages.typescript.javascriptDefaults.setExtraLibs([]);
-      console.log('Cleared Monaco extra libraries');
     } catch (error) {
       console.warn('Error clearing Monaco extra libraries:', error);
     }
@@ -142,7 +136,6 @@ export class MonacoConfig {
           
           const result = await projectApi.openFile(libFilePath);
           if (!result || !result.content) {
-            console.warn(`Failed to load TypeScript lib: ${libFileName}`);
             continue;
           }
           const { content } = result;
@@ -152,7 +145,6 @@ export class MonacoConfig {
             `file:///node_modules/typescript/lib/${libFileName}`
           );
           
-          console.log(`Loaded TypeScript lib: ${libFileName}`);
         } catch (error) {
           console.warn(`Could not load TypeScript lib ${lib}:`, error);
         }
@@ -182,7 +174,6 @@ export class MonacoConfig {
       monaco.languages.typescript.typescriptDefaults.setCompilerOptions(compilerOptions);
       monaco.languages.typescript.javascriptDefaults.setCompilerOptions(compilerOptions);
 
-      console.log('[MonacoConfig] Enhanced module resolution configured');
     } catch (error) {
       console.error('[MonacoConfig] Error setting up module resolution:', error);
     }
diff --git a/src/services/typescript-project/tsconfig-loader.ts b/src/services/typescript-project/tsconfig-loader.ts
@@ -18,19 +18,13 @@ export class TSConfigLoader {
       loadedConfigs.add(configPath);
 
       try {
-        console.log("loading tsconfig from", configPath);
         const result = await projectApi.openFile(configPath);
         if (!result || !result.content) {
           throw new Error(`Failed to read tsconfig from ${configPath}`);
         }
         const { content } = result;
         const cleanedContent = TSConfigLoader.removeJSONComments(content);
-        
-        // Debug logging for JSON parsing issues
-        if (process.env.NODE_ENV === 'development') {
-          console.log('[TSConfigLoader] Original content length:', content.length);
-          console.log('[TSConfigLoader] Cleaned content length:', cleanedContent.length);
-        }
+
         
         try {
           const tsConfig = JSON.parse(cleanedContent) as TSConfig;
@@ -57,7 +51,6 @@ export class TSConfigLoader {
         }
 
       } catch (error) {
-        console.log(`[TSConfigLoader] Failed to load ${configPath}:`, error instanceof Error ? error.message : String(error));
         return null;
       }
     };
@@ -71,12 +64,10 @@ export class TSConfigLoader {
     for (const path of possiblePaths) {
       const tsConfig = await loadAndMerge(path);
       if (tsConfig) {
-        console.log(`[TSConfigLoader] Loaded final tsconfig from ${path}:`, tsConfig);
         return tsConfig;
       }
     }
 
-    console.log('[TSConfigLoader] No valid tsconfig.json or jsconfig.json found.');
     return null;
   }
 
@@ -183,7 +174,6 @@ export class TSConfigLoader {
       const { content } = result;
       return JSON.parse(content);
     } catch (error) {
-      console.log('Could not parse package.json:', error);
       return null;
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -16,20 +16,17 @@ export class DependencyLoader {`
`16`	`16`	`*/`
`17`	`17`	`static async loadProjectDependencyTypes(projectPath: string): Promise<void> {`
`18`	`18`	`try {`
`19`		`- console.log('Loading project dependency types...');`
`20`	`19`
`21`	`20`	`// Parse package.json to get actual dependencies`
`22`	`21`	const packageJsonPath = `${projectPath}/package.json`;
`23`	`22`	`const packageJson = await TSConfigLoader.parsePackageJson(packageJsonPath);`
`24`	`23`
`25`	`24`	`if (!packageJson) {`
`26`		`- console.log('No package.json found, skipping dependency type loading');`
`27`	`25`	`return;`
`28`	`26`	`}`
`29`	`27`
`30`	`28`	`// Get all dependencies`
`31`	`29`	`const allDependencies = DependencyLoader.getAllDependencies(packageJson);`
`32`		- console.log(`Found ${Object.keys(allDependencies).length} dependencies to analyze for types`);
`33`	`30`
`34`	`31`	`// Process dependencies in batches to avoid overwhelming the system`
`35`	`32`	`const batchSize = 10;`
`@@ -48,7 +45,6 @@ export class DependencyLoader {`
`48`	`45`	`}`
`49`	`46`	`}`
`50`	`47`
`51`		`- console.log('Finished loading dependency types');`
`52`	`48`	`} catch (error) {`
`53`	`49`	`console.error('Error loading project dependency types:', error);`
`54`	`50`	`}`
`@@ -81,7 +77,6 @@ export class DependencyLoader {`
`81`	`77`	`// Check if the package exists`
`82`	`78`	const depPackageJson = await TSConfigLoader.parsePackageJson(`${depPath}/package.json`);
`83`	`79`	`if (!depPackageJson) {`
`84`		- console.log(`Package ${dependencyName} not found in node_modules`);
`85`	`80`	`return;`
`86`	`81`	`}`
`87`	`82`
`@@ -105,7 +100,7 @@ export class DependencyLoader {`
`105`	`100`	`}`
`106`	`101`
`107`	`102`	`} catch (error) {`
`108`		- console.log(`Error loading types for ${dependencyName}:`, error);
	`103`	`+ // noop`
`109`	`104`	`}`
`110`	`105`	`}`
`111`	`106`
`@@ -129,7 +124,6 @@ export class DependencyLoader {`
`129`	`124`	`packagePath: string,`
`130`	`125`	`packageJson: PackageJson`
`131`	`126`	`): Promise<void> {`
`132`		- console.log(`Loading framework types for ${packageName}`);
`133`	`127`
`134`	`128`	`// Load built-in types first`
`135`	`129`	`await DependencyLoader.loadBuiltInTypes(packageName, packagePath, packageJson);`
`@@ -208,8 +202,6 @@ export class DependencyLoader {`
`208`	`202`	`}`
`209`	`203`	`}`
`210`	`204`
`211`		- console.log(`Loaded ${totalLoaded} Next.js type files`);
`212`		`-`
`213`	`205`	`// Also try to load @types/react if it exists (Next.js depends on React)`
`214`	`206`	`await DependencyLoader.loadCorrespondingTypesPackage(projectPath, 'react');`
`215`	`207`
`@@ -257,7 +249,7 @@ export class DependencyLoader {`
`257`	`249`
`258`	`250`	`// Try to load all entry points in parallel (truly parallel openFile)`
`259`	`251`	`const loadPromises = typeEntryPoints.map((entryPoint) => {`
`260`		`- const fullPath = entryPoint!.startsWith('/') ?`
	`252`	`+ const fullPath = entryPoint?.startsWith('/') ?`
`261`	`253`	`${packagePath}${entryPoint}` :
`262`	`254`	`${packagePath}/${entryPoint}`;
`263`	`255`
`@@ -268,7 +260,6 @@ export class DependencyLoader {`
`268`	`260`	`const { content } = result;`
`269`	`261`	const virtualPath = `file:///node_modules/${packageName}/${entryPoint}`;
`270`	`262`	`monaco.languages.typescript.typescriptDefaults.addExtraLib(content, virtualPath);`
`271`		- console.log(`Loaded built-in types for ${packageName} from ${entryPoint}`);
`272`	`263`	`return true;`
`273`	`264`	`})`
`274`	`265`	`.catch(() => false);`
`@@ -375,10 +366,6 @@ export class DependencyLoader {`
`375`	`366`	`}`
`376`	`367`	`}`
`377`	`368`
`378`		`- if (totalLoaded > 0) {`
`379`		- console.log(`Loaded ${totalLoaded} type files for ${packageName}`);
`380`		`- }`
`381`		`-`
`382`	`369`	`} catch (error) {`
`383`	`370`	console.warn(`Failed to search for type files in ${packagePath}:`, error);
`384`	`371`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,19 +18,13 @@ export class TSConfigLoader {`
`18`	`18`	`loadedConfigs.add(configPath);`
`19`	`19`
`20`	`20`	`try {`
`21`		`- console.log("loading tsconfig from", configPath);`
`22`	`21`	`const result = await projectApi.openFile(configPath);`
`23`	`22`	`if (!result \|\| !result.content) {`
`24`	`23`	throw new Error(`Failed to read tsconfig from ${configPath}`);
`25`	`24`	`}`
`26`	`25`	`const { content } = result;`
`27`	`26`	`const cleanedContent = TSConfigLoader.removeJSONComments(content);`
`28`		`-`
`29`		`- // Debug logging for JSON parsing issues`
`30`		`- if (process.env.NODE_ENV === 'development') {`
`31`		`- console.log('[TSConfigLoader] Original content length:', content.length);`
`32`		`- console.log('[TSConfigLoader] Cleaned content length:', cleanedContent.length);`
`33`		`- }`
	`27`	`+`
`34`	`28`
`35`	`29`	`try {`
`36`	`30`	`const tsConfig = JSON.parse(cleanedContent) as TSConfig;`
`@@ -57,7 +51,6 @@ export class TSConfigLoader {`
`57`	`51`	`}`
`58`	`52`
`59`	`53`	`} catch (error) {`
`60`		- console.log(`[TSConfigLoader] Failed to load ${configPath}:`, error instanceof Error ? error.message : String(error));
`61`	`54`	`return null;`
`62`	`55`	`}`
`63`	`56`	`};`
`@@ -71,12 +64,10 @@ export class TSConfigLoader {`
`71`	`64`	`for (const path of possiblePaths) {`
`72`	`65`	`const tsConfig = await loadAndMerge(path);`
`73`	`66`	`if (tsConfig) {`
`74`		- console.log(`[TSConfigLoader] Loaded final tsconfig from ${path}:`, tsConfig);
`75`	`67`	`return tsConfig;`
`76`	`68`	`}`
`77`	`69`	`}`
`78`	`70`
`79`		`- console.log('[TSConfigLoader] No valid tsconfig.json or jsconfig.json found.');`
`80`	`71`	`return null;`
`81`	`72`	`}`
`82`	`73`
`@@ -183,7 +174,6 @@ export class TSConfigLoader {`
`183`	`174`	`const { content } = result;`
`184`	`175`	`return JSON.parse(content);`
`185`	`176`	`} catch (error) {`
`186`		`- console.log('Could not parse package.json:', error);`
`187`	`177`	`return null;`
`188`	`178`	`}`
`189`	`179`	`}`