centaurus-cli 3.0.0 → 3.1.0

package/dist/utils/syntax-checker.js

@@ -1,346 +1,298 @@
-import * as vm from 'vm';
-import * as path from 'path';
-import * as fs from 'fs';
-import { spawn } from 'child_process';
-import * as ts from 'typescript';
-/**
- * File extension to language mapping
- */
+import * as vm from "vm";
+import * as path from "path";
+import * as fs from "fs";
+import { spawn } from "child_process";
+import * as ts from "typescript";
 const LANGUAGE_MAP = {
-    // JavaScript
-    '.js': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.jsx': 'javascript',
-    // TypeScript
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.mts': 'typescript',
-    '.cts': 'typescript',
-    // Python
-    '.py': 'python',
-    '.pyw': 'python',
-    // JSON
-    '.json': 'json',
-    '.jsonc': 'json',
-    // Skip syntax checking for these (text/markup/config)
-    '.txt': 'text',
-    '.md': 'markdown',
-    '.markdown': 'markdown',
-    '.log': 'log',
-    '.csv': 'csv',
-    '.html': 'html',
-    '.htm': 'html',
-    '.css': 'css',
-    '.scss': 'scss',
-    '.sass': 'sass',
-    '.less': 'less',
-    '.xml': 'xml',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.toml': 'toml',
-    '.ini': 'ini',
-    '.cfg': 'config',
-    '.conf': 'config',
-    '.env': 'env',
-    '.gitignore': 'gitignore',
-    '.dockerignore': 'dockerignore',
-    '.editorconfig': 'config',
-    '.prettierrc': 'config',
-    '.eslintrc': 'config',
-    '.babelrc': 'config',
+  // JavaScript
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  // TypeScript
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  // Python
+  ".py": "python",
+  ".pyw": "python",
+  // JSON
+  ".json": "json",
+  ".jsonc": "json",
+  // Skip syntax checking for these (text/markup/config)
+  ".txt": "text",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".log": "log",
+  ".csv": "csv",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  ".xml": "xml",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".ini": "ini",
+  ".cfg": "config",
+  ".conf": "config",
+  ".env": "env",
+  ".gitignore": "gitignore",
+  ".dockerignore": "dockerignore",
+  ".editorconfig": "config",
+  ".prettierrc": "config",
+  ".eslintrc": "config",
+  ".babelrc": "config"
 };
-/**
- * Languages that should skip syntax checking
- */
-const SKIP_SYNTAX_CHECK = new Set([
-    'text',
-    'markdown',
-    'log',
-    'csv',
-    'html',
-    'css',
-    'scss',
-    'sass',
-    'less',
-    'xml',
-    'yaml',
-    'toml',
-    'ini',
-    'config',
-    'env',
-    'gitignore',
-    'dockerignore',
+const SKIP_SYNTAX_CHECK = /* @__PURE__ */ new Set([
+  "text",
+  "markdown",
+  "log",
+  "csv",
+  "html",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "xml",
+  "yaml",
+  "toml",
+  "ini",
+  "config",
+  "env",
+  "gitignore",
+  "dockerignore"
 ]);
-/**
- * Detect language from file path
- */
-export function detectLanguage(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const basename = path.basename(filePath).toLowerCase();
-    // Check for special filenames without extensions
-    if (!ext) {
-        // Common config files without extensions
-        if (basename === 'dockerfile')
-            return 'dockerfile';
-        if (basename === 'makefile')
-            return 'makefile';
-        if (basename === '.gitignore')
-            return 'gitignore';
-        if (basename === '.dockerignore')
-            return 'dockerignore';
-        if (basename === '.env')
-            return 'env';
-        return 'unknown';
-    }
-    return LANGUAGE_MAP[ext] || 'unknown';
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const basename = path.basename(filePath).toLowerCase();
+  if (!ext) {
+    if (basename === "dockerfile") return "dockerfile";
+    if (basename === "makefile") return "makefile";
+    if (basename === ".gitignore") return "gitignore";
+    if (basename === ".dockerignore") return "dockerignore";
+    if (basename === ".env") return "env";
+    return "unknown";
+  }
+  return LANGUAGE_MAP[ext] || "unknown";
 }
-/**
- * Check JavaScript syntax using vm.Script
- */
 function checkJavaScriptSyntax(content) {
-    try {
-        // Use vm.Script to parse and check syntax without execution
-        new vm.Script(content, { filename: 'syntax-check.js' });
-        return {
-            success: true,
-            language: 'JavaScript',
-        };
-    }
-    catch (error) {
-        const err = error;
-        return {
-            success: false,
-            language: 'JavaScript',
-            error: err.message,
-        };
-    }
+  try {
+    new vm.Script(content, { filename: "syntax-check.js" });
+    return {
+      success: true,
+      language: "JavaScript"
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      language: "JavaScript",
+      error: err.message
+    };
+  }
 }
-/**
- * Check TypeScript syntax using the TypeScript compiler API
- */
 function checkTypeScriptSyntax(content, filePath) {
-    try {
-        const isTsx = filePath.endsWith('.tsx');
-        const compilerOptions = {
-            noEmit: true,
-            target: ts.ScriptTarget.ESNext,
-            module: ts.ModuleKind.ESNext,
-            jsx: isTsx ? ts.JsxEmit.React : undefined,
-            strict: false, // Don't enforce strict mode for syntax checking
-            skipLibCheck: true,
-            allowJs: true,
-        };
-        // Create a simple in-memory source file
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, isTsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
-        // Check for parse errors (syntax errors)
-        const parseErrors = [];
-        // Walk through the source file to find syntax errors
-        // TypeScript's createSourceFile doesn't throw on syntax errors,
-        // but we can check for diagnostic messages
-        const parseDiagnostics = sourceFile.parseDiagnostics;
-        if (parseDiagnostics && parseDiagnostics.length > 0) {
-            for (const diag of parseDiagnostics) {
-                const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
-                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diag.start || 0);
-                parseErrors.push(`Line ${lineAndChar.line + 1}: ${message}`);
-            }
-        }
-        if (parseErrors.length > 0) {
-            return {
-                success: false,
-                language: 'TypeScript',
-                error: parseErrors.join('\n'),
-            };
-        }
-        return {
-            success: true,
-            language: 'TypeScript',
-        };
+  try {
+    const isTsx = filePath.endsWith(".tsx");
+    const compilerOptions = {
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      jsx: isTsx ? ts.JsxEmit.React : void 0,
+      strict: false,
+      // Don't enforce strict mode for syntax checking
+      skipLibCheck: true,
+      allowJs: true
+    };
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.ESNext,
+      true,
+      isTsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+    );
+    const parseErrors = [];
+    const parseDiagnostics = sourceFile.parseDiagnostics;
+    if (parseDiagnostics && parseDiagnostics.length > 0) {
+      for (const diag of parseDiagnostics) {
+        const message = ts.flattenDiagnosticMessageText(diag.messageText, "\n");
+        const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diag.start || 0);
+        parseErrors.push(`Line ${lineAndChar.line + 1}: ${message}`);
+      }
     }
-    catch (error) {
-        const err = error;
-        return {
-            success: false,
-            language: 'TypeScript',
-            error: err.message,
-        };
+    if (parseErrors.length > 0) {
+      return {
+        success: false,
+        language: "TypeScript",
+        error: parseErrors.join("\n")
+      };
     }
+    return {
+      success: true,
+      language: "TypeScript"
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      language: "TypeScript",
+      error: err.message
+    };
+  }
 }
-/**
- * Check Python syntax using the py_compile module
- */
 async function checkPythonSyntax(filePath) {
-    return new Promise((resolve) => {
-        // Use python -m py_compile to check syntax
-        const pythonCommands = process.platform === 'win32'
-            ? ['python', 'python3', 'py']
-            : ['python3', 'python'];
-        let attemptIndex = 0;
-        const tryNextCommand = () => {
-            if (attemptIndex >= pythonCommands.length) {
-                // No Python found
-                resolve({
-                    success: true,
-                    language: 'Python',
-                    skipped: true,
-                    skipReason: 'Python interpreter not found. Syntax check skipped.',
-                });
-                return;
-            }
-            const pythonCmd = pythonCommands[attemptIndex];
-            attemptIndex++;
-            const proc = spawn(pythonCmd, ['-m', 'py_compile', filePath], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                timeout: 5000, // 5 second timeout
-            });
-            // Close stdin to prevent hanging if python expects input
-            proc.stdin.end();
-            let stderr = '';
-            let timeoutTriggered = false;
-            // Enforce hard timeout and SIGKILL if it hangs
-            const timeoutTimer = setTimeout(() => {
-                timeoutTriggered = true;
-                proc.kill('SIGKILL');
-            }, 5000);
-            proc.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-            proc.on('error', () => {
-                clearTimeout(timeoutTimer);
-                if (timeoutTriggered) {
-                    resolve({
-                        success: false,
-                        language: 'Python',
-                        error: 'Syntax check timed out after 5 seconds',
-                    });
-                    return;
-                }
-                // This python command failed, try next
-                tryNextCommand();
-            });
-            proc.on('close', (code) => {
-                clearTimeout(timeoutTimer);
-                if (timeoutTriggered) {
-                    resolve({
-                        success: false,
-                        language: 'Python',
-                        error: 'Syntax check timed out after 5 seconds',
-                    });
-                    return;
-                }
-                if (code === 0) {
-                    resolve({
-                        success: true,
-                        language: 'Python',
-                    });
-                }
-                else {
-                    // Parse the error message
-                    const errorLines = stderr.trim().split('\n');
-                    const relevantError = errorLines.length > 0
-                        ? errorLines[errorLines.length - 1]
-                        : 'Syntax error detected';
-                    resolve({
-                        success: false,
-                        language: 'Python',
-                        error: relevantError,
-                    });
-                }
-            });
-        };
+  return new Promise((resolve) => {
+    const pythonCommands = process.platform === "win32" ? ["python", "python3", "py"] : ["python3", "python"];
+    let attemptIndex = 0;
+    const tryNextCommand = () => {
+      if (attemptIndex >= pythonCommands.length) {
+        resolve({
+          success: true,
+          language: "Python",
+          skipped: true,
+          skipReason: "Python interpreter not found. Syntax check skipped."
+        });
+        return;
+      }
+      const pythonCmd = pythonCommands[attemptIndex];
+      attemptIndex++;
+      const proc = spawn(pythonCmd, ["-m", "py_compile", filePath], {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+        // 5 second timeout
+      });
+      proc.stdin.end();
+      let stderr = "";
+      let timeoutTriggered = false;
+      const timeoutTimer = setTimeout(() => {
+        timeoutTriggered = true;
+        proc.kill("SIGKILL");
+      }, 5e3);
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", () => {
+        clearTimeout(timeoutTimer);
+        if (timeoutTriggered) {
+          resolve({
+            success: false,
+            language: "Python",
+            error: "Syntax check timed out after 5 seconds"
+          });
+          return;
+        }
         tryNextCommand();
-    });
-}
-/**
- * Check JSON syntax using JSON.parse
- */
-function checkJsonSyntax(content) {
-    try {
-        JSON.parse(content);
-        return {
-            success: true,
-            language: 'JSON',
-        };
-    }
-    catch (error) {
-        const err = error;
-        return {
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeoutTimer);
+        if (timeoutTriggered) {
+          resolve({
             success: false,
-            language: 'JSON',
-            error: err.message,
-        };
-    }
-}
-/**
- * Main syntax check function
- * Checks the syntax of a file based on its extension
- */
-export async function checkSyntax(filePath, content) {
-    const language = detectLanguage(filePath);
-    // Skip syntax checking for text/config files
-    if (SKIP_SYNTAX_CHECK.has(language)) {
-        return {
-            success: true,
-            language: language.charAt(0).toUpperCase() + language.slice(1),
-            skipped: true,
-            skipReason: `Syntax check skipped for ${language} files`,
-        };
-    }
-    // Skip unknown file types
-    if (language === 'unknown') {
-        return {
-            success: true,
-            language: 'Unknown',
-            skipped: true,
-            skipReason: 'Syntax check skipped for unknown file type',
-        };
-    }
-    // Read content from file if not provided
-    let fileContent = content;
-    if (!fileContent) {
-        try {
-            fileContent = fs.readFileSync(filePath, 'utf-8');
+            language: "Python",
+            error: "Syntax check timed out after 5 seconds"
+          });
+          return;
         }
-        catch (error) {
-            return {
-                success: true,
-                language: language.charAt(0).toUpperCase() + language.slice(1),
-                skipped: true,
-                skipReason: 'Could not read file for syntax check',
-            };
+        if (code === 0) {
+          resolve({
+            success: true,
+            language: "Python"
+          });
+        } else {
+          const errorLines = stderr.trim().split("\n");
+          const relevantError = errorLines.length > 0 ? errorLines[errorLines.length - 1] : "Syntax error detected";
+          resolve({
+            success: false,
+            language: "Python",
+            error: relevantError
+          });
         }
-    }
-    // Perform language-specific syntax check
-    switch (language) {
-        case 'javascript':
-            return checkJavaScriptSyntax(fileContent);
-        case 'typescript':
-            return checkTypeScriptSyntax(fileContent, filePath);
-        case 'python':
-            // Python requires the file to be on disk for py_compile
-            return await checkPythonSyntax(filePath);
-        case 'json':
-            return checkJsonSyntax(fileContent);
-        default:
-            return {
-                success: true,
-                language: language.charAt(0).toUpperCase() + language.slice(1),
-                skipped: true,
-                skipReason: `Syntax check not implemented for ${language}`,
-            };
-    }
+      });
+    };
+    tryNextCommand();
+  });
 }
-/**
- * Format syntax check result as a human-readable string
- */
-export function formatSyntaxCheckResult(result) {
-    if (result.skipped) {
-        return `(${result.skipReason})`;
-    }
-    if (result.success) {
-        return `✓ Syntax check passed (${result.language})`;
+function checkJsonSyntax(content) {
+  try {
+    JSON.parse(content);
+    return {
+      success: true,
+      language: "JSON"
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      language: "JSON",
+      error: err.message
+    };
+  }
+}
+async function checkSyntax(filePath, content) {
+  const language = detectLanguage(filePath);
+  if (SKIP_SYNTAX_CHECK.has(language)) {
+    return {
+      success: true,
+      language: language.charAt(0).toUpperCase() + language.slice(1),
+      skipped: true,
+      skipReason: `Syntax check skipped for ${language} files`
+    };
+  }
+  if (language === "unknown") {
+    return {
+      success: true,
+      language: "Unknown",
+      skipped: true,
+      skipReason: "Syntax check skipped for unknown file type"
+    };
+  }
+  let fileContent = content;
+  if (!fileContent) {
+    try {
+      fileContent = fs.readFileSync(filePath, "utf-8");
+    } catch (error) {
+      return {
+        success: true,
+        language: language.charAt(0).toUpperCase() + language.slice(1),
+        skipped: true,
+        skipReason: "Could not read file for syntax check"
+      };
     }
-    return `✗ Syntax error (${result.language}): ${result.error}`;
+  }
+  switch (language) {
+    case "javascript":
+      return checkJavaScriptSyntax(fileContent);
+    case "typescript":
+      return checkTypeScriptSyntax(fileContent, filePath);
+    case "python":
+      return await checkPythonSyntax(filePath);
+    case "json":
+      return checkJsonSyntax(fileContent);
+    default:
+      return {
+        success: true,
+        language: language.charAt(0).toUpperCase() + language.slice(1),
+        skipped: true,
+        skipReason: `Syntax check not implemented for ${language}`
+      };
+  }
 }
+function formatSyntaxCheckResult(result) {
+  if (result.skipped) {
+    return `(${result.skipReason})`;
+  }
+  if (result.success) {
+    return `\u2713 Syntax check passed (${result.language})`;
+  }
+  return `\u2717 Syntax error (${result.language}): ${result.error}`;
+}
+export {
+  checkSyntax,
+  detectLanguage,
+  formatSyntaxCheckResult
+};
 //# sourceMappingURL=syntax-checker.js.map