@loxia-labs/loxia-autopilot-one 1.0.1

package/src/analyzers/PrettierFormatter.js

@@ -0,0 +1,247 @@
+/**
+ * PrettierFormatter - Code formatting using Prettier
+ *
+ * Purpose:
+ * - Format code according to consistent style rules
+ * - Support multiple languages (JS, TS, CSS, HTML, JSON, etc.)
+ * - Detect and use project's Prettier configuration
+ * - Provide before/after comparison
+ */
+
+import prettier from 'prettier';
+import path from 'path';
+import fs from 'fs/promises';
+
+class PrettierFormatter {
+  constructor(logger = null) {
+    this.logger = logger;
+    this.configCache = new Map();
+  }
+
+  /**
+   * Format code with Prettier
+   * @param {string} filePath - Path to file
+   * @param {string} content - File content
+   * @param {Object} options - Format options
+   * @returns {Promise<Object>} Formatted content and changes
+   */
+  async format(filePath, content, options = {}) {
+    try {
+      // Get Prettier configuration
+      const config = await this.getPrettierConfig(filePath, options.workingDir);
+
+      // Determine parser from file extension
+      const parser = this.getParser(filePath);
+
+      // Format the code
+      const formatted = await prettier.format(content, {
+        ...config,
+        filepath: filePath,
+        parser
+      });
+
+      // Check if formatting made changes
+      const hasChanges = formatted !== content;
+
+      return {
+        formatted: hasChanges,
+        content: formatted,
+        original: content,
+        changes: hasChanges ? this.describeChanges(content, formatted) : [],
+        linesChanged: hasChanges ? this.countChangedLines(content, formatted) : 0
+      };
+
+    } catch (error) {
+      this.logger?.error('Prettier formatting failed', {
+        file: filePath,
+        error: error.message
+      });
+
+      throw new Error(`Prettier formatting failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if file needs formatting
+   * @param {string} filePath - Path to file
+   * @param {string} content - File content
+   * @param {Object} options - Check options
+   * @returns {Promise<boolean>} True if file needs formatting
+   */
+  async check(filePath, content, options = {}) {
+    try {
+      const config = await this.getPrettierConfig(filePath, options.workingDir);
+      const parser = this.getParser(filePath);
+
+      const formatted = await prettier.format(content, {
+        ...config,
+        filepath: filePath,
+        parser
+      });
+
+      return formatted !== content;
+
+    } catch (error) {
+      this.logger?.warn('Prettier check failed', {
+        file: filePath,
+        error: error.message
+      });
+
+      return false;
+    }
+  }
+
+  /**
+   * Get Prettier configuration
+   * @private
+   */
+  async getPrettierConfig(filePath, workingDir) {
+    // Check cache
+    const cacheKey = workingDir || path.dirname(filePath);
+    if (this.configCache.has(cacheKey)) {
+      return this.configCache.get(cacheKey);
+    }
+
+    let config = {};
+
+    // Try to load project's Prettier config
+    if (workingDir) {
+      try {
+        const projectConfig = await prettier.resolveConfig(filePath, {
+          config: workingDir
+        });
+
+        if (projectConfig) {
+          this.logger?.debug('Found Prettier config', { workingDir });
+          config = projectConfig;
+        }
+      } catch (error) {
+        this.logger?.debug('No Prettier config found, using defaults');
+      }
+    }
+
+    // Default configuration
+    const defaultConfig = {
+      semi: true,
+      singleQuote: true,
+      tabWidth: 2,
+      trailingComma: 'es5',
+      printWidth: 100,
+      arrowParens: 'avoid',
+      endOfLine: 'lf',
+      ...config
+    };
+
+    // Cache the configuration
+    this.configCache.set(cacheKey, defaultConfig);
+
+    return defaultConfig;
+  }
+
+  /**
+   * Get parser for file type
+   * @private
+   */
+  getParser(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    const parserMap = {
+      '.js': 'babel',
+      '.jsx': 'babel',
+      '.mjs': 'babel',
+      '.cjs': 'babel',
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.json': 'json',
+      '.json5': 'json5',
+      '.css': 'css',
+      '.scss': 'scss',
+      '.less': 'less',
+      '.html': 'html',
+      '.vue': 'vue',
+      '.md': 'markdown',
+      '.yaml': 'yaml',
+      '.yml': 'yaml'
+    };
+
+    return parserMap[ext] || 'babel';
+  }
+
+  /**
+   * Describe changes made by formatting
+   * @private
+   */
+  describeChanges(original, formatted) {
+    const changes = [];
+    const originalLines = original.split('\n');
+    const formattedLines = formatted.split('\n');
+
+    const maxLines = Math.max(originalLines.length, formattedLines.length);
+
+    for (let i = 0; i < maxLines; i++) {
+      const origLine = originalLines[i];
+      const formattedLine = formattedLines[i];
+
+      if (origLine !== formattedLine) {
+        changes.push({
+          line: i + 1,
+          type: origLine !== undefined && formattedLine !== undefined
+            ? 'modified'
+            : (origLine !== undefined ? 'removed' : 'added'),
+          original: origLine || '',
+          formatted: formattedLine || ''
+        });
+      }
+    }
+
+    return changes;
+  }
+
+  /**
+   * Count changed lines
+   * @private
+   */
+  countChangedLines(original, formatted) {
+    const originalLines = original.split('\n');
+    const formattedLines = formatted.split('\n');
+    let changedCount = 0;
+
+    const maxLines = Math.max(originalLines.length, formattedLines.length);
+
+    for (let i = 0; i < maxLines; i++) {
+      if (originalLines[i] !== formattedLines[i]) {
+        changedCount++;
+      }
+    }
+
+    return changedCount;
+  }
+
+  /**
+   * Get supported file extensions
+   * @returns {Array<string>} Array of supported extensions
+   */
+  getSupportedExtensions() {
+    return [
+      '.js', '.jsx', '.mjs', '.cjs',
+      '.ts', '.tsx',
+      '.json', '.json5',
+      '.css', '.scss', '.less',
+      '.html', '.vue',
+      '.md',
+      '.yaml', '.yml'
+    ];
+  }
+
+  /**
+   * Check if file type is supported
+   * @param {string} filePath - Path to file
+   * @returns {boolean} True if supported
+   */
+  isSupported(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return this.getSupportedExtensions().includes(ext);
+  }
+}
+
+export default PrettierFormatter;

package/src/analyzers/PythonAnalyzer.js

@@ -0,0 +1,266 @@
+/**
+ * PythonAnalyzer - Python code analysis using Python's ast module
+ *
+ * Purpose:
+ * - Analyze Python code for syntax errors
+ * - Detect import issues
+ * - Support Django, Flask, FastAPI frameworks
+ * - Use Python's built-in ast module via subprocess
+ */
+
+import { spawn } from 'child_process';
+import { STATIC_ANALYSIS } from '../utilities/constants.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+class PythonAnalyzer {
+  constructor(logger = null) {
+    this.logger = logger;
+    this.pythonCommand = null;
+  }
+
+  /**
+   * Analyze Python code
+   * @param {string} filePath - Path to file
+   * @param {string} content - File content
+   * @param {Object} options - Analysis options
+   * @returns {Promise<Array>} Array of diagnostics
+   */
+  async analyze(filePath, content, options = {}) {
+    try {
+      const diagnostics = [];
+
+      // Check if Python is available
+      const pythonCmd = await this.getPythonCommand();
+      if (!pythonCmd) {
+        this.logger?.warn('Python not available, skipping analysis');
+        return [];
+      }
+
+      // Run syntax check using Python's ast module
+      const syntaxErrors = await this.checkSyntax(filePath, content, pythonCmd);
+      diagnostics.push(...syntaxErrors);
+
+      this.logger?.debug('Python 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('Python analysis failed', {
+        file: filePath,
+        error: error.message
+      });
+
+      // Return empty array on error to allow other analysis to continue
+      return [];
+    }
+  }
+
+  /**
+   * Check Python syntax using ast module
+   * @private
+   */
+  async checkSyntax(filePath, content, pythonCmd) {
+    const diagnostics = [];
+
+    // Create a temporary Python script to check syntax
+    const tempDir = os.tmpdir();
+    const tempScript = path.join(tempDir, `syntax_check_${Date.now()}.py`);
+    const tempFile = path.join(tempDir, `target_${Date.now()}.py`);
+
+    try {
+      // Write the content to a temporary file
+      await fs.writeFile(tempFile, content, 'utf-8');
+
+      // Create syntax checker script
+      const checkerScript = `
+import ast
+import sys
+import json
+
+def check_syntax(filepath):
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            source = f.read()
+
+        # Try to parse the file
+        ast.parse(source, filename=filepath)
+
+        # If successful, no errors
+        print(json.dumps({"success": True, "errors": []}))
+
+    except SyntaxError as e:
+        error = {
+            "file": filepath,
+            "line": e.lineno or 1,
+            "column": e.offset or 1,
+            "message": str(e.msg),
+            "text": e.text.strip() if e.text else ""
+        }
+        print(json.dumps({"success": False, "errors": [error]}))
+
+    except Exception as e:
+        error = {
+            "file": filepath,
+            "line": 1,
+            "column": 1,
+            "message": str(e),
+            "text": ""
+        }
+        print(json.dumps({"success": False, "errors": [error]}))
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        check_syntax(sys.argv[1])
+    else:
+        print(json.dumps({"success": False, "errors": [{"message": "No file specified"}]}))
+`;
+
+      await fs.writeFile(tempScript, checkerScript, 'utf-8');
+
+      // Run the checker script
+      const result = await this.runPythonScript(pythonCmd, tempScript, [tempFile]);
+
+      // Parse the result
+      try {
+        const parsed = JSON.parse(result.stdout);
+
+        if (!parsed.success && parsed.errors) {
+          for (const error of parsed.errors) {
+            diagnostics.push({
+              file: filePath,
+              line: error.line || 1,
+              column: error.column || 1,
+              severity: STATIC_ANALYSIS.SEVERITY.ERROR,
+              rule: 'SyntaxError',
+              message: error.message,
+              category: STATIC_ANALYSIS.CATEGORY.SYNTAX,
+              fixable: false,
+              source: 'python-ast',
+              code: error.text || undefined
+            });
+          }
+        }
+      } catch (parseError) {
+        this.logger?.warn('Failed to parse Python syntax check result', {
+          error: parseError.message,
+          stdout: result.stdout
+        });
+      }
+
+    } finally {
+      // Clean up temporary files
+      try {
+        await fs.unlink(tempScript);
+        await fs.unlink(tempFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+
+    return diagnostics;
+  }
+
+  /**
+   * Get Python command (python3 or python)
+   * @private
+   */
+  async getPythonCommand() {
+    if (this.pythonCommand) {
+      return this.pythonCommand;
+    }
+
+    // Try python3 first, then python
+    const commands = ['python3', 'python'];
+
+    for (const cmd of commands) {
+      try {
+        const result = await this.runCommand(cmd, ['--version']);
+        if (result.success) {
+          this.pythonCommand = cmd;
+          this.logger?.debug('Found Python command', { command: cmd, version: result.stdout.trim() });
+          return cmd;
+        }
+      } catch {
+        // Continue to next command
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Run Python script
+   * @private
+   */
+  async runPythonScript(pythonCmd, scriptPath, args = []) {
+    return this.runCommand(pythonCmd, [scriptPath, ...args]);
+  }
+
+  /**
+   * Run command and capture output
+   * @private
+   */
+  async runCommand(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(command, args, {
+        ...options,
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('error', (error) => {
+        reject(error);
+      });
+
+      proc.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          code,
+          stdout,
+          stderr
+        });
+      });
+
+      // Timeout after 10 seconds
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error('Command timeout'));
+      }, 10000);
+    });
+  }
+
+  /**
+   * Get supported file extensions
+   * @returns {Array<string>} Array of supported extensions
+   */
+  getSupportedExtensions() {
+    return ['.py'];
+  }
+
+  /**
+   * Check if auto-fix is supported
+   * @returns {boolean} True if auto-fix is supported
+   */
+  supportsAutoFix() {
+    return false;  // Python auto-fix not implemented yet
+  }
+}
+
+export default PythonAnalyzer;