onbuzz 4.9.13 → 4.10.0

package/src/analyzers/TypeScriptAnalyzer.js

@@ -1,247 +1,247 @@
-/**
- * TypeScriptAnalyzer - Analyze TypeScript files for errors using TypeScript Compiler API
- *
- * Purpose:
- * - Analyze TypeScript files for syntax, type, and semantic errors
- * - Use TypeScript Compiler API with full type checking
- * - Provide detailed error information with line numbers
- * - Support TSX syntax
- */
-
-import ts from 'typescript';
-import path from 'path';
-import { STATIC_ANALYSIS } from '../utilities/constants.js';
-
-class TypeScriptAnalyzer {
-  constructor(logger = null) {
-    this.logger = logger;
-    this.compilerOptions = {
-      noEmit: true,
-      jsx: ts.JsxEmit.React,
-      target: ts.ScriptTarget.Latest,
-      module: ts.ModuleKind.ESNext,
-      moduleResolution: ts.ModuleResolutionKind.NodeJs,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      strict: true, // Enable strict type checking for TypeScript
-      noImplicitAny: true,
-      strictNullChecks: true,
-      strictFunctionTypes: true,
-      allowJs: false // TypeScript only
-    };
-  }
-
-  /**
-   * Analyze TypeScript file for errors
-   * @param {string} filePath - Path to file
-   * @param {string} content - File content
-   * @param {Object} options - Analysis options
-   * @returns {Promise<Array>} Array of diagnostic errors
-   */
-  async analyze(filePath, content, options = {}) {
-    try {
-      const diagnostics = [];
-
-      // Create in-memory source file
-      const sourceFile = ts.createSourceFile(
-        filePath,
-        content,
-        ts.ScriptTarget.Latest,
-        true // setParentNodes
-      );
-
-      // Get syntactic diagnostics (syntax errors)
-      const syntacticDiagnostics = this.getSyntacticDiagnostics(sourceFile);
-      diagnostics.push(...syntacticDiagnostics);
-
-      // Get semantic diagnostics (type errors, undefined variables, etc.)
-      const semanticDiagnostics = await this.getSemanticDiagnostics(filePath, content);
-      diagnostics.push(...semanticDiagnostics);
-
-      this.logger?.debug('TypeScript analysis completed', {
-        file: filePath,
-        totalDiagnostics: diagnostics.length,
-        errors: diagnostics.filter(d => d.severity === STATIC_ANALYSIS.SEVERITY.ERROR).length,
-        warnings: diagnostics.filter(d => d.severity === STATIC_ANALYSIS.SEVERITY.WARNING).length
-      });
-
-      return diagnostics;
-
-    } catch (error) {
-      this.logger?.error('TypeScript analysis failed', {
-        file: filePath,
-        error: error.message
-      });
-
-      return [{
-        file: filePath,
-        line: 0,
-        column: 0,
-        severity: STATIC_ANALYSIS.SEVERITY.ERROR,
-        rule: 'analyzer-error',
-        message: `Analysis failed: ${error.message}`,
-        category: STATIC_ANALYSIS.CATEGORY.SYNTAX
-      }];
-    }
-  }
-
-  /**
-   * Get syntactic diagnostics (syntax errors)
-   * @private
-   */
-  getSyntacticDiagnostics(sourceFile) {
-    const diagnostics = [];
-
-    // Check for parsing errors
-    if (sourceFile.parseDiagnostics && sourceFile.parseDiagnostics.length > 0) {
-      for (const diagnostic of sourceFile.parseDiagnostics) {
-        diagnostics.push(this.formatDiagnostic(diagnostic, sourceFile));
-      }
-    }
-
-    return diagnostics;
-  }
-
-  /**
-   * Get semantic diagnostics (type errors, undefined variables)
-   * @private
-   */
-  async getSemanticDiagnostics(filePath, content) {
-    const diagnostics = [];
-
-    try {
-      // Create a minimal program for semantic analysis
-      const sourceFile = ts.createSourceFile(
-        filePath,
-        content,
-        ts.ScriptTarget.Latest,
-        true
-      );
-
-      // Create a compiler host that provides files from memory
-      const host = {
-        getSourceFile: (fileName) => {
-          if (fileName === filePath) {
-            return sourceFile;
-          }
-          // Return undefined for library files - they won't be available
-          return undefined;
-        },
-        getDefaultLibFileName: () => 'lib.d.ts',
-        writeFile: () => {},
-        getCurrentDirectory: () => path.dirname(filePath),
-        getDirectories: () => [],
-        fileExists: (fileName) => fileName === filePath,
-        readFile: (fileName) => {
-          if (fileName === filePath) {
-            return content;
-          }
-          return undefined;
-        },
-        getCanonicalFileName: (fileName) => fileName,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => '\n'
-      };
-
-      // Create program
-      const program = ts.createProgram({
-        rootNames: [filePath],
-        options: this.compilerOptions,
-        host
-      });
-
-      // Get all diagnostics
-      const syntactic = program.getSyntacticDiagnostics(sourceFile);
-      const semantic = program.getSemanticDiagnostics(sourceFile);
-
-      for (const diagnostic of [...syntactic, ...semantic]) {
-        diagnostics.push(this.formatDiagnostic(diagnostic, sourceFile));
-      }
-
-    } catch (error) {
-      this.logger?.debug('Semantic analysis encountered error', {
-        file: filePath,
-        error: error.message
-      });
-    }
-
-    return diagnostics;
-  }
-
-  /**
-   * Format TypeScript diagnostic to standard error format
-   * @private
-   */
-  formatDiagnostic(diagnostic, sourceFile) {
-    let line = 0;
-    let column = 0;
-
-    if (diagnostic.file && diagnostic.start !== undefined) {
-      const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-      line = position.line + 1; // 1-indexed
-      column = position.character + 1;
-    } else if (sourceFile && diagnostic.start !== undefined) {
-      const position = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-      line = position.line + 1;
-      column = position.character + 1;
-    }
-
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-
-    // Determine severity
-    let severity;
-    switch (diagnostic.category) {
-      case ts.DiagnosticCategory.Error:
-        severity = STATIC_ANALYSIS.SEVERITY.ERROR;
-        break;
-      case ts.DiagnosticCategory.Warning:
-        severity = STATIC_ANALYSIS.SEVERITY.WARNING;
-        break;
-      case ts.DiagnosticCategory.Message:
-      case ts.DiagnosticCategory.Suggestion:
-        severity = STATIC_ANALYSIS.SEVERITY.INFO;
-        break;
-      default:
-        severity = STATIC_ANALYSIS.SEVERITY.ERROR;
-    }
-
-    // Determine category based on error code and message
-    let category = STATIC_ANALYSIS.CATEGORY.SYNTAX;
-    const code = diagnostic.code;
-
-    // Categorize based on error code ranges
-    if (code >= 2000 && code < 3000) {
-      category = STATIC_ANALYSIS.CATEGORY.TYPE;
-    } else if (code >= 1000 && code < 2000) {
-      category = STATIC_ANALYSIS.CATEGORY.SYNTAX;
-    } else if (code >= 2300 && code < 2400) {
-      category = STATIC_ANALYSIS.CATEGORY.IMPORT;
-    }
-
-    // Check message content for more specific categorization
-    const lowerMessage = message.toLowerCase();
-    if (lowerMessage.includes('cannot find module') ||
-        lowerMessage.includes('import') ||
-        lowerMessage.includes('export')) {
-      category = STATIC_ANALYSIS.CATEGORY.IMPORT;
-    } else if (lowerMessage.includes('type') ||
-               lowerMessage.includes('interface') ||
-               lowerMessage.includes('class')) {
-      category = STATIC_ANALYSIS.CATEGORY.TYPE;
-    }
-
-    return {
-      file: diagnostic.file?.fileName || sourceFile?.fileName || 'unknown',
-      line,
-      column,
-      severity,
-      rule: `TS${code}`,
-      message,
-      category,
-      fixable: false, // TypeScript doesn't provide fix information easily
-      code: diagnostic.code
-    };
-  }
-}
-
-export default TypeScriptAnalyzer;
+/**
+ * TypeScriptAnalyzer - Analyze TypeScript files for errors using TypeScript Compiler API
+ *
+ * Purpose:
+ * - Analyze TypeScript files for syntax, type, and semantic errors
+ * - Use TypeScript Compiler API with full type checking
+ * - Provide detailed error information with line numbers
+ * - Support TSX syntax
+ */
+
+import ts from 'typescript';
+import path from 'path';
+import { STATIC_ANALYSIS } from '../utilities/constants.js';
+
+class TypeScriptAnalyzer {
+  constructor(logger = null) {
+    this.logger = logger;
+    this.compilerOptions = {
+      noEmit: true,
+      jsx: ts.JsxEmit.React,
+      target: ts.ScriptTarget.Latest,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.NodeJs,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      strict: true, // Enable strict type checking for TypeScript
+      noImplicitAny: true,
+      strictNullChecks: true,
+      strictFunctionTypes: true,
+      allowJs: false // TypeScript only
+    };
+  }
+
+  /**
+   * Analyze TypeScript file for errors
+   * @param {string} filePath - Path to file
+   * @param {string} content - File content
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Array>} Array of diagnostic errors
+   */
+  async analyze(filePath, content) {
+    try {
+      const diagnostics = [];
+
+      // Create in-memory source file
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true // setParentNodes
+      );
+
+      // Get syntactic diagnostics (syntax errors)
+      const syntacticDiagnostics = this.getSyntacticDiagnostics(sourceFile);
+      diagnostics.push(...syntacticDiagnostics);
+
+      // Get semantic diagnostics (type errors, undefined variables, etc.)
+      const semanticDiagnostics = await this.getSemanticDiagnostics(filePath, content);
+      diagnostics.push(...semanticDiagnostics);
+
+      this.logger?.debug('TypeScript analysis completed', {
+        file: filePath,
+        totalDiagnostics: diagnostics.length,
+        errors: diagnostics.filter(d => d.severity === STATIC_ANALYSIS.SEVERITY.ERROR).length,
+        warnings: diagnostics.filter(d => d.severity === STATIC_ANALYSIS.SEVERITY.WARNING).length
+      });
+
+      return diagnostics;
+
+    } catch (error) {
+      this.logger?.error('TypeScript analysis failed', {
+        file: filePath,
+        error: error.message
+      });
+
+      return [{
+        file: filePath,
+        line: 0,
+        column: 0,
+        severity: STATIC_ANALYSIS.SEVERITY.ERROR,
+        rule: 'analyzer-error',
+        message: `Analysis failed: ${error.message}`,
+        category: STATIC_ANALYSIS.CATEGORY.SYNTAX
+      }];
+    }
+  }
+
+  /**
+   * Get syntactic diagnostics (syntax errors)
+   * @private
+   */
+  getSyntacticDiagnostics(sourceFile) {
+    const diagnostics = [];
+
+    // Check for parsing errors
+    if (sourceFile.parseDiagnostics && sourceFile.parseDiagnostics.length > 0) {
+      for (const diagnostic of sourceFile.parseDiagnostics) {
+        diagnostics.push(this.formatDiagnostic(diagnostic, sourceFile));
+      }
+    }
+
+    return diagnostics;
+  }
+
+  /**
+   * Get semantic diagnostics (type errors, undefined variables)
+   * @private
+   */
+  async getSemanticDiagnostics(filePath, content) {
+    const diagnostics = [];
+
+    try {
+      // Create a minimal program for semantic analysis
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        true
+      );
+
+      // Create a compiler host that provides files from memory
+      const host = {
+        getSourceFile: (fileName) => {
+          if (fileName === filePath) {
+            return sourceFile;
+          }
+          // Return undefined for library files - they won't be available
+          return undefined;
+        },
+        getDefaultLibFileName: () => 'lib.d.ts',
+        writeFile: () => {},
+        getCurrentDirectory: () => path.dirname(filePath),
+        getDirectories: () => [],
+        fileExists: (fileName) => fileName === filePath,
+        readFile: (fileName) => {
+          if (fileName === filePath) {
+            return content;
+          }
+          return undefined;
+        },
+        getCanonicalFileName: (fileName) => fileName,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n'
+      };
+
+      // Create program
+      const program = ts.createProgram({
+        rootNames: [filePath],
+        options: this.compilerOptions,
+        host
+      });
+
+      // Get all diagnostics
+      const syntactic = program.getSyntacticDiagnostics(sourceFile);
+      const semantic = program.getSemanticDiagnostics(sourceFile);
+
+      for (const diagnostic of [...syntactic, ...semantic]) {
+        diagnostics.push(this.formatDiagnostic(diagnostic, sourceFile));
+      }
+
+    } catch (error) {
+      this.logger?.debug('Semantic analysis encountered error', {
+        file: filePath,
+        error: error.message
+      });
+    }
+
+    return diagnostics;
+  }
+
+  /**
+   * Format TypeScript diagnostic to standard error format
+   * @private
+   */
+  formatDiagnostic(diagnostic, sourceFile) {
+    let line = 0;
+    let column = 0;
+
+    if (diagnostic.file && diagnostic.start !== undefined) {
+      const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+      line = position.line + 1; // 1-indexed
+      column = position.character + 1;
+    } else if (sourceFile && diagnostic.start !== undefined) {
+      const position = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+      line = position.line + 1;
+      column = position.character + 1;
+    }
+
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+
+    // Determine severity
+    let severity;
+    switch (diagnostic.category) {
+      case ts.DiagnosticCategory.Error:
+        severity = STATIC_ANALYSIS.SEVERITY.ERROR;
+        break;
+      case ts.DiagnosticCategory.Warning:
+        severity = STATIC_ANALYSIS.SEVERITY.WARNING;
+        break;
+      case ts.DiagnosticCategory.Message:
+      case ts.DiagnosticCategory.Suggestion:
+        severity = STATIC_ANALYSIS.SEVERITY.INFO;
+        break;
+      default:
+        severity = STATIC_ANALYSIS.SEVERITY.ERROR;
+    }
+
+    // Determine category based on error code and message
+    let category = STATIC_ANALYSIS.CATEGORY.SYNTAX;
+    const code = diagnostic.code;
+
+    // Categorize based on error code ranges
+    if (code >= 2000 && code < 3000) {
+      category = STATIC_ANALYSIS.CATEGORY.TYPE;
+    } else if (code >= 1000 && code < 2000) {
+      category = STATIC_ANALYSIS.CATEGORY.SYNTAX;
+    } else if (code >= 2300 && code < 2400) {
+      category = STATIC_ANALYSIS.CATEGORY.IMPORT;
+    }
+
+    // Check message content for more specific categorization
+    const lowerMessage = message.toLowerCase();
+    if (lowerMessage.includes('cannot find module') ||
+        lowerMessage.includes('import') ||
+        lowerMessage.includes('export')) {
+      category = STATIC_ANALYSIS.CATEGORY.IMPORT;
+    } else if (lowerMessage.includes('type') ||
+               lowerMessage.includes('interface') ||
+               lowerMessage.includes('class')) {
+      category = STATIC_ANALYSIS.CATEGORY.TYPE;
+    }
+
+    return {
+      file: diagnostic.file?.fileName || sourceFile?.fileName || 'unknown',
+      line,
+      column,
+      severity,
+      rule: `TS${code}`,
+      message,
+      category,
+      fixable: false, // TypeScript doesn't provide fix information easily
+      code: diagnostic.code
+    };
+  }
+}
+
+export default TypeScriptAnalyzer;

package/src/analyzers/__tests__/CSSAnalyzer.test.js

@@ -1,41 +1,41 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { createMockLogger } from '../../__test-utils__/mockFactories.js';
-import CSSAnalyzer from '../CSSAnalyzer.js';
-
-describe('CSSAnalyzer', () => {
-  let logger;
-
-  beforeEach(() => {
-    logger = createMockLogger();
-  });
-
-  test('constructor creates instance', () => {
-    const analyzer = new CSSAnalyzer(logger);
-    expect(analyzer).toBeInstanceOf(CSSAnalyzer);
-    expect(analyzer.logger).toBe(logger);
-  });
-
-  test('detectLanguage returns css for .css file', () => {
-    const analyzer = new CSSAnalyzer(logger);
-    expect(analyzer.detectLanguage('styles.css')).toBe('css');
-  });
-
-  test('detectLanguage returns scss for .scss file', () => {
-    const analyzer = new CSSAnalyzer(logger);
-    expect(analyzer.detectLanguage('styles.scss')).toBe('scss');
-  });
-
-  test('getSupportedExtensions returns array including .css', () => {
-    const analyzer = new CSSAnalyzer(logger);
-    const extensions = analyzer.getSupportedExtensions();
-    expect(Array.isArray(extensions)).toBe(true);
-    expect(extensions).toContain('.css');
-    expect(extensions).toContain('.scss');
-    expect(extensions).toContain('.less');
-  });
-
-  test('supportsAutoFix returns false', () => {
-    const analyzer = new CSSAnalyzer(logger);
-    expect(analyzer.supportsAutoFix()).toBe(false);
-  });
-});
+import { describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+import CSSAnalyzer from '../CSSAnalyzer.js';
+
+describe('CSSAnalyzer', () => {
+  let logger;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+  });
+
+  test('constructor creates instance', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer).toBeInstanceOf(CSSAnalyzer);
+    expect(analyzer.logger).toBe(logger);
+  });
+
+  test('detectLanguage returns css for .css file', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.detectLanguage('styles.css')).toBe('css');
+  });
+
+  test('detectLanguage returns scss for .scss file', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.detectLanguage('styles.scss')).toBe('scss');
+  });
+
+  test('getSupportedExtensions returns array including .css', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    const extensions = analyzer.getSupportedExtensions();
+    expect(Array.isArray(extensions)).toBe(true);
+    expect(extensions).toContain('.css');
+    expect(extensions).toContain('.scss');
+    expect(extensions).toContain('.less');
+  });
+
+  test('supportsAutoFix returns false', () => {
+    const analyzer = new CSSAnalyzer(logger);
+    expect(analyzer.supportsAutoFix()).toBe(false);
+  });
+});