@aiready/consistency 0.21.8 → 0.21.11

package/dist/chunk-66M3TIO7.mjs

@@ -1,837 +0,0 @@
-// src/analyzers/naming-ast.ts
-import { Severity as Severity2 } from "@aiready/core";
-
-// src/utils/ast-parser.ts
-import { parse } from "@typescript-eslint/typescript-estree";
-import { readFileSync } from "fs";
-function parseFile(filePath, content) {
-  try {
-    const code = content ?? readFileSync(filePath, "utf-8");
-    const isTypeScript = filePath.match(/\.tsx?$/);
-    return parse(code, {
-      jsx: filePath.match(/\.[jt]sx$/i) !== null,
-      loc: true,
-      range: true,
-      comment: false,
-      tokens: false,
-      // Relaxed parsing for JavaScript files
-      sourceType: "module",
-      ecmaVersion: "latest",
-      // Only use TypeScript parser features for .ts/.tsx files
-      filePath: isTypeScript ? filePath : void 0
-    });
-  } catch (error) {
-    void error;
-    return null;
-  }
-}
-function traverseAST(node, visitor, parent = null) {
-  if (!node) return;
-  visitor.enter?.(node, parent);
-  for (const key of Object.keys(node)) {
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        if (child && typeof child === "object" && "type" in child) {
-          traverseAST(child, visitor, node);
-        }
-      }
-    } else if (value && typeof value === "object" && "type" in value) {
-      traverseAST(value, visitor, node);
-    }
-  }
-  visitor.leave?.(node, parent);
-}
-function isLoopStatement(node) {
-  return [
-    "ForStatement",
-    "ForInStatement",
-    "ForOfStatement",
-    "WhileStatement",
-    "DoWhileStatement"
-  ].includes(node.type);
-}
-function getLineNumber(node) {
-  return node.loc?.start.line ?? 0;
-}
-
-// src/utils/context-detector.ts
-import { Severity } from "@aiready/core";
-function detectFileType(filePath, ast) {
-  void ast;
-  const path = filePath.toLowerCase();
-  if (path.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/) || path.includes("__tests__")) {
-    return "test";
-  }
-  if (path.endsWith(".d.ts") || path.includes("types")) {
-    return "types";
-  }
-  if (path.match(/config|\.config\.|rc\.|setup/) || path.includes("configuration")) {
-    return "config";
-  }
-  return "production";
-}
-function detectCodeLayer(ast) {
-  let hasAPIIndicators = 0;
-  let hasBusinessIndicators = 0;
-  let hasDataIndicators = 0;
-  let hasUtilityIndicators = 0;
-  traverseAST(ast, {
-    enter: (node) => {
-      if (node.type === "ImportDeclaration") {
-        const source = node.source.value;
-        if (source.match(/express|fastify|koa|@nestjs|axios|fetch|http/i)) {
-          hasAPIIndicators++;
-        }
-        if (source.match(/database|prisma|typeorm|sequelize|mongoose|pg|mysql/i)) {
-          hasDataIndicators++;
-        }
-      }
-      if (node.type === "FunctionDeclaration" && node.id) {
-        const name = node.id.name;
-        if (name.match(
-          /^(get|post|put|delete|patch|handle|api|route|controller)/i
-        )) {
-          hasAPIIndicators++;
-        }
-        if (name.match(/^(calculate|process|validate|transform|compute|analyze)/i)) {
-          hasBusinessIndicators++;
-        }
-        if (name.match(/^(find|create|update|delete|save|fetch|query|insert)/i)) {
-          hasDataIndicators++;
-        }
-        if (name.match(
-          /^(format|parse|convert|normalize|sanitize|encode|decode)/i
-        )) {
-          hasUtilityIndicators++;
-        }
-      }
-      if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
-        if (node.type === "ExportNamedDeclaration" && node.declaration) {
-          if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-            const name = node.declaration.id.name;
-            if (name.match(/handler|route|api|controller/i)) {
-              hasAPIIndicators += 2;
-            }
-          }
-        }
-      }
-    }
-  });
-  const scores = {
-    api: hasAPIIndicators,
-    business: hasBusinessIndicators,
-    data: hasDataIndicators,
-    utility: hasUtilityIndicators
-  };
-  const maxScore = Math.max(...Object.values(scores));
-  if (maxScore === 0) {
-    return "unknown";
-  }
-  if (scores.api === maxScore) return "api";
-  if (scores.data === maxScore) return "data";
-  if (scores.business === maxScore) return "business";
-  if (scores.utility === maxScore) return "utility";
-  return "unknown";
-}
-function calculateComplexity(node) {
-  let complexity = 1;
-  traverseAST(node, {
-    enter: (childNode) => {
-      switch (childNode.type) {
-        case "IfStatement":
-        case "ConditionalExpression":
-        // ternary
-        case "SwitchCase":
-        case "ForStatement":
-        case "ForInStatement":
-        case "ForOfStatement":
-        case "WhileStatement":
-        case "DoWhileStatement":
-        case "CatchClause":
-          complexity++;
-          break;
-        case "LogicalExpression":
-          if (childNode.operator === "&&" || childNode.operator === "||") {
-            complexity++;
-          }
-          break;
-      }
-    }
-  });
-  return complexity;
-}
-function buildCodeContext(filePath, ast) {
-  const fileType = detectFileType(filePath, ast);
-  const codeLayer = detectCodeLayer(ast);
-  let totalComplexity = 0;
-  let functionCount = 0;
-  traverseAST(ast, {
-    enter: (node) => {
-      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-        totalComplexity += calculateComplexity(node);
-        functionCount++;
-      }
-    }
-  });
-  const avgComplexity = functionCount > 0 ? totalComplexity / functionCount : 1;
-  return {
-    fileType,
-    codeLayer,
-    complexity: Math.round(avgComplexity),
-    isTestFile: fileType === "test",
-    isTypeDefinition: fileType === "types"
-  };
-}
-function adjustSeverity(baseSeverity, context, issueType) {
-  const getEnum = (s) => {
-    if (s === Severity.Critical || s === "critical") return Severity.Critical;
-    if (s === Severity.Major || s === "major") return Severity.Major;
-    if (s === Severity.Minor || s === "minor") return Severity.Minor;
-    return Severity.Info;
-  };
-  let currentSev = getEnum(baseSeverity);
-  if (context.isTestFile) {
-    if (currentSev === Severity.Minor) currentSev = Severity.Info;
-    if (currentSev === Severity.Major) currentSev = Severity.Minor;
-  }
-  if (context.isTypeDefinition) {
-    if (currentSev === Severity.Minor) currentSev = Severity.Info;
-  }
-  if (context.codeLayer === "api") {
-    if (currentSev === Severity.Info && issueType === "unclear")
-      currentSev = Severity.Minor;
-    if (currentSev === Severity.Minor && issueType === "unclear")
-      currentSev = Severity.Major;
-  }
-  if (context.complexity > 10) {
-    if (currentSev === Severity.Info) currentSev = Severity.Minor;
-  }
-  if (context.codeLayer === "utility") {
-    if (currentSev === Severity.Minor && issueType === "abbreviation")
-      currentSev = Severity.Info;
-  }
-  return currentSev;
-}
-function isAcceptableInContext(name, context, options) {
-  if (options.isLoopVariable && ["i", "j", "k", "l", "n", "m"].includes(name)) {
-    return true;
-  }
-  if (context.isTestFile) {
-    if (["a", "b", "c", "x", "y", "z"].includes(name) && options.isParameter) {
-      return true;
-    }
-  }
-  if (context.codeLayer === "utility" && ["x", "y", "z"].includes(name)) {
-    return true;
-  }
-  if (options.isDestructured) {
-    if (["s", "b", "f", "l"].includes(name)) {
-      return true;
-    }
-  }
-  if (options.isParameter && (options.complexity ?? context.complexity) < 3) {
-    if (name.length >= 2) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/analyzers/naming-ast.ts
-async function analyzeNamingAST(filePaths) {
-  const allIssues = [];
-  for (const filePath of filePaths) {
-    try {
-      const ast = parseFile(filePath);
-      if (!ast) continue;
-      const context = buildCodeContext(filePath, ast);
-      const issues = analyzeIdentifiers(ast, filePath, context);
-      allIssues.push(...issues);
-    } catch (err) {
-      void err;
-    }
-  }
-  return allIssues;
-}
-function analyzeIdentifiers(ast, filePath, context) {
-  const issues = [];
-  const scopeTracker = new ScopeTracker();
-  traverseAST(ast, {
-    enter: (node) => {
-      if (node.type === "VariableDeclarator" && node.id.type === "Identifier") {
-        const isParameter = false;
-        const isLoopVariable = isLoopStatement(node.parent?.parent);
-        scopeTracker.declareVariable(
-          node.id.name,
-          node.id,
-          getLineNumber(node.id),
-          { isParameter, isLoopVariable }
-        );
-      }
-      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-        node.params.forEach((param) => {
-          if (param.type === "Identifier") {
-            scopeTracker.declareVariable(
-              param.name,
-              param,
-              getLineNumber(param),
-              { isParameter: true }
-            );
-          } else if (param.type === "ObjectPattern") {
-            extractDestructuredIdentifiers(param, true, scopeTracker);
-          }
-        });
-      }
-      if ((node.type === "ClassDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") && node.id) {
-        checkNamingConvention(
-          node.id.name,
-          "PascalCase",
-          node.id,
-          filePath,
-          issues,
-          context
-        );
-      }
-    }
-  });
-  for (const varInfo of scopeTracker.getVariables()) {
-    checkVariableNaming(varInfo, filePath, issues, context);
-  }
-  return issues;
-}
-function checkNamingConvention(name, convention, node, file, issues, context) {
-  let isValid = true;
-  if (convention === "PascalCase") {
-    isValid = /^[A-Z][a-zA-Z0-9]*$/.test(name);
-  } else if (convention === "camelCase") {
-    isValid = /^[a-z][a-zA-Z0-9]*$/.test(name);
-  } else if (convention === "UPPER_CASE") {
-    isValid = /^[A-Z][A-Z0-9_]*$/.test(name);
-  }
-  if (!isValid) {
-    const severity = adjustSeverity(Severity2.Info, context, "convention-mix");
-    issues.push({
-      file,
-      line: getLineNumber(node),
-      type: "convention-mix",
-      identifier: name,
-      severity,
-      suggestion: `Follow ${convention} for this identifier`
-    });
-  }
-}
-function checkVariableNaming(varInfo, file, issues, context) {
-  const { name, node, line, options } = varInfo;
-  if (isAcceptableInContext(name, context, options)) {
-    return;
-  }
-  if (name.length === 1 && !options.isLoopVariable) {
-    const severity = adjustSeverity(Severity2.Minor, context, "poor-naming");
-    issues.push({
-      file,
-      line,
-      type: "poor-naming",
-      identifier: name,
-      severity,
-      suggestion: "Use a more descriptive name than a single letter"
-    });
-  }
-  const vagueNames = [
-    "data",
-    "info",
-    "item",
-    "obj",
-    "val",
-    "tmp",
-    "temp",
-    "thing",
-    "stuff"
-  ];
-  if (vagueNames.includes(name.toLowerCase())) {
-    const severity = adjustSeverity(Severity2.Minor, context, "poor-naming");
-    issues.push({
-      file,
-      line,
-      type: "poor-naming",
-      identifier: name,
-      severity,
-      suggestion: `Avoid vague names like '${name}'. What does this data represent?`
-    });
-  }
-  if (name.length > 1 && name.length <= 3 && !options.isLoopVariable && !isCommonAbbreviation(name)) {
-    const severity = adjustSeverity(Severity2.Info, context, "abbreviation");
-    issues.push({
-      file,
-      line,
-      type: "abbreviation",
-      identifier: name,
-      severity,
-      suggestion: "Avoid non-standard abbreviations"
-    });
-  }
-}
-function isCommonAbbreviation(name) {
-  const common = [
-    "id",
-    "db",
-    "fs",
-    "os",
-    "ip",
-    "ui",
-    "ux",
-    "api",
-    "env",
-    "url"
-  ];
-  return common.includes(name.toLowerCase());
-}
-var ScopeTracker = class {
-  constructor() {
-    this.variables = [];
-  }
-  declareVariable(name, node, line, options = {}) {
-    this.variables.push({ name, node, line, options });
-  }
-  getVariables() {
-    return this.variables;
-  }
-};
-function extractDestructuredIdentifiers(node, isParameter, scopeTracker) {
-  if (node.type === "ObjectPattern") {
-    node.properties.forEach((prop) => {
-      if (prop.type === "Property" && prop.value.type === "Identifier") {
-        scopeTracker.declareVariable(
-          prop.value.name,
-          prop.value,
-          getLineNumber(prop.value),
-          {
-            isParameter,
-            isDestructured: true
-          }
-        );
-      }
-    });
-  } else if (node.type === "ArrayPattern") {
-    for (const element of node.elements) {
-      if (element?.type === "Identifier") {
-        scopeTracker.declareVariable(
-          element.name,
-          element,
-          getLineNumber(element),
-          {
-            isParameter,
-            isDestructured: true
-          }
-        );
-      }
-    }
-  }
-}
-
-// src/analyzers/patterns.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { Severity as Severity3 } from "@aiready/core";
-async function analyzePatterns(filePaths) {
-  const issues = [];
-  const contents = /* @__PURE__ */ new Map();
-  const tryCatchPattern = /try\s*\{/g;
-  const catchPattern = /catch\s*\(\s*(\w+)\s*\)/g;
-  const styleStats = {
-    tryCatch: 0,
-    thenCatch: 0,
-    asyncAwait: 0,
-    commonJs: 0,
-    esm: 0
-  };
-  for (const filePath of filePaths) {
-    try {
-      const content = readFileSync2(filePath, "utf-8");
-      contents.set(filePath, content);
-      if (content.match(tryCatchPattern)) styleStats.tryCatch++;
-      if (content.match(/\.catch\s*\(/)) styleStats.thenCatch++;
-      if (content.match(/\bawait\b/)) styleStats.asyncAwait++;
-      if (content.match(/\brequire\s*\(/)) styleStats.commonJs++;
-      if (content.match(/\bimport\b.*\bfrom\b/)) styleStats.esm++;
-    } catch (err) {
-      void err;
-    }
-  }
-  const totalFiles = filePaths.length;
-  if (styleStats.tryCatch > 0 && styleStats.thenCatch > 0) {
-    const dominant = styleStats.tryCatch >= styleStats.thenCatch ? "try-catch" : ".catch()";
-    const minority = dominant === "try-catch" ? ".catch()" : "try-catch";
-    issues.push({
-      files: filePaths.filter((f) => {
-        const c = contents.get(f) || "";
-        return minority === "try-catch" ? c.match(tryCatchPattern) : c.match(/\.catch\s*\(/);
-      }),
-      type: "error-handling",
-      description: `Mixed error handling styles: codebase primarily uses ${dominant}, but found ${minority} in some files.`,
-      examples: [dominant, minority],
-      severity: Severity3.Minor
-    });
-  }
-  if (styleStats.commonJs > 0 && styleStats.esm > 0) {
-    const minority = styleStats.esm >= styleStats.commonJs ? "CommonJS (require)" : "ESM (import)";
-    issues.push({
-      files: filePaths.filter((f) => {
-        const c = contents.get(f) || "";
-        return minority === "CommonJS (require)" ? c.match(/\brequire\s*\(/) : c.match(/\bimport\b/);
-      }),
-      type: "import-style",
-      description: `Mixed module systems: found both ESM and CommonJS.`,
-      examples: ['import X from "y"', 'const X = require("y")'],
-      severity: Severity3.Major
-    });
-  }
-  return issues;
-}
-
-// src/analyzer.ts
-import { scanFiles, Severity as Severity4, IssueType, GLOBAL_SCAN_OPTIONS } from "@aiready/core";
-
-// src/analyzers/naming-python.ts
-import { getParser } from "@aiready/core";
-async function analyzePythonNaming(files) {
-  const issues = [];
-  const parser = getParser("dummy.py");
-  if (!parser) {
-    console.warn("Python parser not available");
-    return issues;
-  }
-  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
-  for (const file of pythonFiles) {
-    try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
-      const result = parser.parse(code, file);
-      for (const exp of result.exports) {
-        const nameIssue = checkPythonNaming(
-          exp.name,
-          exp.type,
-          file,
-          exp.loc?.start.line || 0
-        );
-        if (nameIssue) {
-          issues.push(nameIssue);
-        }
-      }
-      for (const imp of result.imports) {
-        for (const spec of imp.specifiers) {
-          if (spec !== "*" && spec !== "default") {
-            const nameIssue = checkPythonNaming(
-              spec,
-              "variable",
-              file,
-              imp.loc?.start.line || 0
-            );
-            if (nameIssue) {
-              issues.push(nameIssue);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      console.warn(`Skipping ${file} due to error:`, error);
-    }
-  }
-  return issues;
-}
-function checkPythonNaming(identifier, type, file, line) {
-  const parser = getParser("dummy.py");
-  const conventions = parser?.getNamingConventions();
-  if (!conventions) return null;
-  if (conventions.exceptions?.includes(identifier)) {
-    return null;
-  }
-  if (type === "class") {
-    if (!conventions.classPattern.test(identifier)) {
-      return {
-        type: "poor-naming",
-        identifier,
-        file,
-        line,
-        column: 0,
-        severity: "major",
-        category: "naming",
-        suggestion: `Class names should use PascalCase (e.g., ${toPascalCase(identifier)})`
-      };
-    }
-  } else if (type === "function") {
-    if (!conventions.functionPattern.test(identifier)) {
-      if (/^[a-z][a-zA-Z0-9]*$/.test(identifier) && /[A-Z]/.test(identifier)) {
-        return {
-          type: "convention-mix",
-          identifier,
-          file,
-          line,
-          column: 0,
-          severity: "major",
-          category: "naming",
-          suggestion: `Function names should use snake_case, not camelCase (e.g., ${toSnakeCase(identifier)})`
-        };
-      }
-    }
-  } else if (type === "const" || type === "variable") {
-    if (identifier === identifier.toUpperCase() && identifier.length > 1) {
-      if (!conventions.constantPattern.test(identifier)) {
-        return {
-          type: "poor-naming",
-          identifier,
-          file,
-          line,
-          column: 0,
-          severity: "minor",
-          category: "naming",
-          suggestion: "Constants should use UPPER_CASE_WITH_UNDERSCORES"
-        };
-      }
-    } else {
-      if (!conventions.variablePattern.test(identifier)) {
-        if (/^[a-z][a-zA-Z0-9]*$/.test(identifier) && /[A-Z]/.test(identifier)) {
-          return {
-            type: "convention-mix",
-            identifier,
-            file,
-            line,
-            column: 0,
-            severity: "major",
-            category: "naming",
-            suggestion: `Variable names should use snake_case, not camelCase (e.g., ${toSnakeCase(identifier)})`
-          };
-        }
-      }
-    }
-  }
-  return null;
-}
-function toSnakeCase(str) {
-  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
-}
-function toPascalCase(str) {
-  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-
-// src/analyzer.ts
-async function analyzeConsistency(options) {
-  const {
-    checkNaming = true,
-    checkPatterns = true,
-    checkArchitecture = false,
-    // Not implemented yet
-    minSeverity = Severity4.Info,
-    ...scanOptions
-  } = options;
-  void checkArchitecture;
-  const filePaths = await scanFiles(scanOptions);
-  const tsJsFiles = filePaths.filter((f) => /\.(ts|tsx|js|jsx)$/i.test(f));
-  const pythonFiles = filePaths.filter((f) => /\.py$/i.test(f));
-  let namingIssues = [];
-  if (checkNaming) {
-    const tsJsNamingIssues = tsJsFiles.length > 0 ? await analyzeNamingAST(tsJsFiles) : [];
-    const pythonNamingIssues = pythonFiles.length > 0 ? await analyzePythonNaming(pythonFiles) : [];
-    namingIssues = [...tsJsNamingIssues, ...pythonNamingIssues];
-  }
-  const patternIssues = checkPatterns ? await analyzePatterns(filePaths) : [];
-  const results = [];
-  const fileIssuesMap = /* @__PURE__ */ new Map();
-  for (const issue of namingIssues) {
-    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
-      continue;
-    }
-    const consistencyIssue = {
-      type: issue.type === "convention-mix" ? IssueType.NamingInconsistency : IssueType.NamingQuality,
-      category: "naming",
-      severity: getSeverityEnum(issue.severity),
-      message: `${issue.type}: ${issue.identifier}`,
-      location: {
-        file: issue.file,
-        line: issue.line,
-        column: issue.column
-      },
-      suggestion: issue.suggestion
-    };
-    if (!fileIssuesMap.has(issue.file)) {
-      fileIssuesMap.set(issue.file, []);
-    }
-    fileIssuesMap.get(issue.file).push(consistencyIssue);
-  }
-  for (const issue of patternIssues) {
-    if (!shouldIncludeSeverity(issue.severity, minSeverity)) {
-      continue;
-    }
-    const consistencyIssue = {
-      type: IssueType.PatternInconsistency,
-      category: "patterns",
-      severity: getSeverityEnum(issue.severity),
-      message: issue.description,
-      location: {
-        file: issue.files[0] || "multiple files",
-        line: 1
-      },
-      examples: issue.examples,
-      suggestion: `Standardize ${issue.type} patterns across ${issue.files.length} files`
-    };
-    const firstFile = issue.files[0];
-    if (firstFile && !fileIssuesMap.has(firstFile)) {
-      fileIssuesMap.set(firstFile, []);
-    }
-    if (firstFile) {
-      fileIssuesMap.get(firstFile).push(consistencyIssue);
-    }
-  }
-  for (const [fileName, issues] of fileIssuesMap) {
-    results.push({
-      fileName,
-      issues,
-      metrics: {
-        consistencyScore: calculateConsistencyScore(issues)
-      }
-    });
-  }
-  results.sort((fileResultA, fileResultB) => {
-    const maxSeverityA = Math.min(
-      ...fileResultA.issues.map((i) => {
-        const val = getSeverityLevel(i.severity);
-        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
-      })
-    );
-    const maxSeverityB = Math.min(
-      ...fileResultB.issues.map((i) => {
-        const val = getSeverityLevel(i.severity);
-        return val === 4 ? 0 : val === 3 ? 1 : val === 2 ? 2 : 3;
-      })
-    );
-    if (maxSeverityA !== maxSeverityB) {
-      return maxSeverityA - maxSeverityB;
-    }
-    return fileResultB.issues.length - fileResultA.issues.length;
-  });
-  const recommendations = generateRecommendations(namingIssues, patternIssues);
-  const namingCountFiltered = namingIssues.filter(
-    (i) => shouldIncludeSeverity(i.severity, minSeverity)
-  ).length;
-  const patternCountFiltered = patternIssues.filter(
-    (i) => shouldIncludeSeverity(i.severity, minSeverity)
-  ).length;
-  return {
-    summary: {
-      totalIssues: namingCountFiltered + patternCountFiltered,
-      namingIssues: namingCountFiltered,
-      patternIssues: patternCountFiltered,
-      architectureIssues: 0,
-      filesAnalyzed: filePaths.length,
-      config: Object.fromEntries(
-        Object.entries(options).filter(
-          ([key]) => !GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
-        )
-      )
-    },
-    results,
-    recommendations
-  };
-}
-function getSeverityLevel(s) {
-  if (s === Severity4.Critical || s === "critical") return 4;
-  if (s === Severity4.Major || s === "major") return 3;
-  if (s === Severity4.Minor || s === "minor") return 2;
-  if (s === Severity4.Info || s === "info") return 1;
-  return 0;
-}
-function getSeverityEnum(s) {
-  const val = getSeverityLevel(s);
-  switch (val) {
-    case 4:
-      return Severity4.Critical;
-    case 3:
-      return Severity4.Major;
-    case 2:
-      return Severity4.Minor;
-    case 1:
-      return Severity4.Info;
-    default:
-      return Severity4.Info;
-  }
-}
-function shouldIncludeSeverity(severity, minSeverity) {
-  return getSeverityLevel(severity) >= getSeverityLevel(minSeverity);
-}
-function calculateConsistencyScore(issues) {
-  let totalWeight = 0;
-  for (const issue of issues) {
-    const val = getSeverityLevel(issue.severity);
-    switch (val) {
-      case 4:
-        totalWeight += 10;
-        break;
-      case 3:
-        totalWeight += 5;
-        break;
-      case 2:
-        totalWeight += 2;
-        break;
-      case 1:
-        totalWeight += 1;
-        break;
-      default:
-        totalWeight += 1;
-    }
-  }
-  return Math.max(0, 1 - totalWeight / 100);
-}
-function generateRecommendations(namingIssues, patternIssues) {
-  const recommendations = [];
-  if (namingIssues.length > 0) {
-    const conventionMixCount = namingIssues.filter(
-      (i) => i.type === "convention-mix"
-    ).length;
-    if (conventionMixCount > 0) {
-      recommendations.push(
-        `Standardize naming conventions: Found ${conventionMixCount} snake_case variables in TypeScript/JavaScript (use camelCase)`
-      );
-    }
-    const poorNamingCount = namingIssues.filter(
-      (i) => i.type === "poor-naming"
-    ).length;
-    if (poorNamingCount > 0) {
-      recommendations.push(
-        `Improve variable naming: Found ${poorNamingCount} single-letter or unclear variable names`
-      );
-    }
-  }
-  if (patternIssues.length > 0) {
-    const errorHandlingIssues = patternIssues.filter(
-      (i) => i.type === "error-handling"
-    );
-    if (errorHandlingIssues.length > 0) {
-      recommendations.push(
-        "Standardize error handling strategy across the codebase (prefer try-catch with typed errors)"
-      );
-    }
-    const asyncIssues = patternIssues.filter((i) => i.type === "async-style");
-    if (asyncIssues.length > 0) {
-      recommendations.push(
-        "Use async/await consistently instead of mixing with promise chains or callbacks"
-      );
-    }
-    const importIssues = patternIssues.filter((i) => i.type === "import-style");
-    if (importIssues.length > 0) {
-      recommendations.push(
-        "Use ES modules consistently across the project (avoid mixing with CommonJS)"
-      );
-    }
-  }
-  if (recommendations.length === 0) {
-    recommendations.push(
-      "No major consistency issues found! Your codebase follows good practices."
-    );
-  }
-  return recommendations;
-}
-
-export {
-  analyzeNamingAST,
-  analyzePatterns,
-  analyzeConsistency
-};