@aiready/consistency 0.21.9 → 0.21.12

package/dist/chunk-Q5XMWG33.mjs

@@ -1,661 +0,0 @@
-// src/analyzers/naming.ts
-import { readFileContent } from "@aiready/core";
-var COMMON_SHORT_WORDS = /* @__PURE__ */ new Set([
-  // Full English words (1-3 letters)
-  "day",
-  "key",
-  "net",
-  "to",
-  "go",
-  "for",
-  "not",
-  "new",
-  "old",
-  "top",
-  "end",
-  "run",
-  "try",
-  "use",
-  "get",
-  "set",
-  "add",
-  "put",
-  "map",
-  "log",
-  "row",
-  "col",
-  "tab",
-  "box",
-  "div",
-  "nav",
-  "tag",
-  "any",
-  "all",
-  "one",
-  "two",
-  "out",
-  "off",
-  "on",
-  "yes",
-  "no",
-  "now",
-  "max",
-  "min",
-  "sum",
-  "avg",
-  "ref",
-  "src",
-  "dst",
-  "raw",
-  "def",
-  "sub",
-  "pub",
-  "pre",
-  "mid",
-  "alt",
-  "opt",
-  "tmp",
-  "ext",
-  "sep"
-]);
-var ACCEPTABLE_ABBREVIATIONS = /* @__PURE__ */ new Set([
-  // Standard identifiers
-  "id",
-  "uid",
-  "gid",
-  "pid",
-  // Web/Network
-  "url",
-  "uri",
-  "api",
-  "cdn",
-  "dns",
-  "ip",
-  "tcp",
-  "udp",
-  "http",
-  "ssl",
-  "tls",
-  "utm",
-  "seo",
-  "rss",
-  "xhr",
-  "ajax",
-  "cors",
-  "ws",
-  "wss",
-  // Data formats
-  "json",
-  "xml",
-  "yaml",
-  "csv",
-  "html",
-  "css",
-  "svg",
-  "pdf",
-  // File types & extensions
-  "img",
-  "txt",
-  "doc",
-  "docx",
-  "xlsx",
-  "ppt",
-  "md",
-  "rst",
-  "jpg",
-  "png",
-  "gif",
-  // Databases
-  "db",
-  "sql",
-  "orm",
-  "dao",
-  "dto",
-  "ddb",
-  "rds",
-  "nosql",
-  // File system
-  "fs",
-  "dir",
-  "tmp",
-  "src",
-  "dst",
-  "bin",
-  "lib",
-  "pkg",
-  // Operating system
-  "os",
-  "env",
-  "arg",
-  "cli",
-  "cmd",
-  "exe",
-  "cwd",
-  "pwd",
-  // UI/UX
-  "ui",
-  "ux",
-  "gui",
-  "dom",
-  "ref",
-  // Request/Response
-  "req",
-  "res",
-  "ctx",
-  "err",
-  "msg",
-  "auth",
-  // Mathematics/Computing
-  "max",
-  "min",
-  "avg",
-  "sum",
-  "abs",
-  "cos",
-  "sin",
-  "tan",
-  "log",
-  "exp",
-  "pow",
-  "sqrt",
-  "std",
-  "var",
-  "int",
-  "num",
-  "idx",
-  // Time
-  "now",
-  "utc",
-  "tz",
-  "ms",
-  "sec",
-  "hr",
-  "min",
-  "yr",
-  "mo",
-  // Common patterns
-  "app",
-  "cfg",
-  "config",
-  "init",
-  "len",
-  "val",
-  "str",
-  "obj",
-  "arr",
-  "gen",
-  "def",
-  "raw",
-  "new",
-  "old",
-  "pre",
-  "post",
-  "sub",
-  "pub",
-  // Programming/Framework specific
-  "ts",
-  "js",
-  "jsx",
-  "tsx",
-  "py",
-  "rb",
-  "vue",
-  "re",
-  "fn",
-  "fns",
-  "mod",
-  "opts",
-  // Cloud/Infrastructure
-  "s3",
-  "ec2",
-  "sqs",
-  "sns",
-  "vpc",
-  "ami",
-  "iam",
-  "acl",
-  "elb",
-  "alb",
-  "nlb",
-  // Metrics/Performance
-  "fcp",
-  "lcp",
-  "cls",
-  "ttfb",
-  "tti",
-  "fid",
-  "fps",
-  "qps",
-  "rps",
-  "tps",
-  // Testing & i18n
-  "po",
-  "e2e",
-  "a11y",
-  "i18n",
-  "l10n",
-  // Boolean helpers (these are intentional short names)
-  "is",
-  "has",
-  "can",
-  "did",
-  "was",
-  "are",
-  // Date/Time context (when in date contexts)
-  "d",
-  "t",
-  "dt"
-]);
-async function analyzeNaming(files) {
-  const issues = [];
-  for (const file of files) {
-    const content = await readFileContent(file);
-    const fileIssues = analyzeFileNaming(file, content);
-    issues.push(...fileIssues);
-  }
-  return issues;
-}
-function analyzeFileNaming(file, content) {
-  const issues = [];
-  const isTestFile = file.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/);
-  const lines = content.split("\n");
-  lines.forEach((line, index) => {
-    const lineNumber = index + 1;
-    const singleLetterMatches = line.matchAll(/\b(?:const|let|var)\s+([a-hm-z])\s*=/gi);
-    for (const match of singleLetterMatches) {
-      const letter = match[1].toLowerCase();
-      const isInLoopContext = line.includes("for") || /\.(map|filter|forEach|reduce|find|some|every)\s*\(/.test(line) || line.includes("=>") || // Arrow function
-      /\w+\s*=>\s*/.test(line);
-      const isI18nContext = line.includes("useTranslation") || line.includes("i18n.t") || /\bt\s*\(['"]/.test(line);
-      if (!isInLoopContext && !isI18nContext && !["x", "y", "z", "i", "j", "k", "l", "n", "m"].includes(letter)) {
-        if (isTestFile && ["a", "b", "c", "d", "e", "f"].includes(letter)) {
-          continue;
-        }
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "poor-naming",
-          identifier: match[1],
-          severity: "minor",
-          suggestion: `Use descriptive variable name instead of single letter '${match[1]}'`
-        });
-      }
-    }
-    const abbreviationMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z]{1,3})(?=[A-Z]|_|\s*=)/g);
-    for (const match of abbreviationMatches) {
-      const abbrev = match[1].toLowerCase();
-      if (COMMON_SHORT_WORDS.has(abbrev)) {
-        continue;
-      }
-      if (ACCEPTABLE_ABBREVIATIONS.has(abbrev)) {
-        continue;
-      }
-      if (abbrev.length <= 2) {
-        const isDateTimeContext = /date|time|day|hour|minute|second|timestamp/i.test(line);
-        if (isDateTimeContext && ["d", "t", "dt"].includes(abbrev)) {
-          continue;
-        }
-        const isUserContext = /user|auth|account/i.test(line);
-        if (isUserContext && abbrev === "u") {
-          continue;
-        }
-      }
-      issues.push({
-        file,
-        line: lineNumber,
-        type: "abbreviation",
-        identifier: match[1],
-        severity: "info",
-        suggestion: `Consider using full word instead of abbreviation '${match[1]}'`
-      });
-    }
-    if (file.match(/\.(ts|tsx|js|jsx)$/)) {
-      const camelCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*=/);
-      const snakeCaseVars = line.match(/\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\s*=/);
-      if (snakeCaseVars) {
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "convention-mix",
-          identifier: snakeCaseVars[1],
-          severity: "minor",
-          suggestion: `Use camelCase '${snakeCaseToCamelCase(snakeCaseVars[1])}' instead of snake_case in TypeScript/JavaScript`
-        });
-      }
-    }
-    const booleanMatches = line.matchAll(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*)\s*:\s*boolean/gi);
-    for (const match of booleanMatches) {
-      const name = match[1];
-      if (!name.match(/^(is|has|should|can|will|did)/i)) {
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "unclear",
-          identifier: name,
-          severity: "info",
-          suggestion: `Boolean variable '${name}' should start with is/has/should/can for clarity`
-        });
-      }
-    }
-    const functionMatches = line.matchAll(/function\s+([a-z][a-zA-Z0-9]*)/g);
-    for (const match of functionMatches) {
-      const name = match[1];
-      const isFactoryPattern = name.match(/(Factory|Builder|Creator|Generator)$/);
-      const isEventHandler = name.match(/^on[A-Z]/);
-      const isDescriptiveLong = name.length > 15;
-      const isDescriptivePattern = name.match(/^(default|total|count|sum|avg|max|min|initial|current|previous|next)\w+/) || name.match(/\w+(Count|Total|Sum|Average|List|Map|Set|Config|Settings|Options|Props)$/);
-      const capitalCount = (name.match(/[A-Z]/g) || []).length;
-      const isCompoundWord = capitalCount >= 3;
-      const hasActionVerb = name.match(/^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce|make|do|run|start|stop|build|parse|format|render|calculate|compute|generate|transform|convert|normalize|sanitize|encode|decode|compress|extract|merge|split|join|sort|compare|test|verify|ensure|apply|execute|invoke|call|emit|dispatch|trigger|listen|subscribe|unsubscribe|add|remove|clear|reset|toggle|enable|disable|open|close|connect|disconnect|send|receive|read|write|import|export|register|unregister|mount|unmount)/);
-      if (!hasActionVerb && !isFactoryPattern && !isEventHandler && !isDescriptiveLong && !isDescriptivePattern && !isCompoundWord) {
-        issues.push({
-          file,
-          line: lineNumber,
-          type: "unclear",
-          identifier: name,
-          severity: "info",
-          suggestion: `Function '${name}' should start with an action verb (get, set, create, etc.)`
-        });
-      }
-    }
-  });
-  return issues;
-}
-function snakeCaseToCamelCase(str) {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function detectNamingConventions(files, allIssues) {
-  const camelCaseCount = allIssues.filter((i) => i.type === "convention-mix").length;
-  const totalChecks = files.length * 10;
-  if (camelCaseCount / totalChecks > 0.3) {
-    return { dominantConvention: "mixed", conventionScore: 0.5 };
-  }
-  return { dominantConvention: "camelCase", conventionScore: 0.9 };
-}
-
-// src/analyzers/patterns.ts
-import { readFileContent as readFileContent2 } from "@aiready/core";
-async function analyzePatterns(files) {
-  const issues = [];
-  const errorHandlingIssues = await analyzeErrorHandling(files);
-  issues.push(...errorHandlingIssues);
-  const asyncIssues = await analyzeAsyncPatterns(files);
-  issues.push(...asyncIssues);
-  const importIssues = await analyzeImportStyles(files);
-  issues.push(...importIssues);
-  return issues;
-}
-async function analyzeErrorHandling(files) {
-  const patterns = {
-    tryCatch: [],
-    throwsError: [],
-    returnsNull: [],
-    returnsError: []
-  };
-  for (const file of files) {
-    const content = await readFileContent2(file);
-    if (content.includes("try {") || content.includes("} catch")) {
-      patterns.tryCatch.push(file);
-    }
-    if (content.match(/throw new \w*Error/)) {
-      patterns.throwsError.push(file);
-    }
-    if (content.match(/return null/)) {
-      patterns.returnsNull.push(file);
-    }
-    if (content.match(/return \{ error:/)) {
-      patterns.returnsError.push(file);
-    }
-  }
-  const issues = [];
-  const strategiesUsed = Object.values(patterns).filter((p) => p.length > 0).length;
-  if (strategiesUsed > 2) {
-    issues.push({
-      files: [.../* @__PURE__ */ new Set([
-        ...patterns.tryCatch,
-        ...patterns.throwsError,
-        ...patterns.returnsNull,
-        ...patterns.returnsError
-      ])],
-      type: "error-handling",
-      description: "Inconsistent error handling strategies across codebase",
-      examples: [
-        patterns.tryCatch.length > 0 ? `Try-catch used in ${patterns.tryCatch.length} files` : "",
-        patterns.throwsError.length > 0 ? `Throws errors in ${patterns.throwsError.length} files` : "",
-        patterns.returnsNull.length > 0 ? `Returns null in ${patterns.returnsNull.length} files` : "",
-        patterns.returnsError.length > 0 ? `Returns error objects in ${patterns.returnsError.length} files` : ""
-      ].filter((e) => e),
-      severity: "major"
-    });
-  }
-  return issues;
-}
-async function analyzeAsyncPatterns(files) {
-  const patterns = {
-    asyncAwait: [],
-    promises: [],
-    callbacks: []
-  };
-  for (const file of files) {
-    const content = await readFileContent2(file);
-    if (content.match(/async\s+(function|\(|[a-zA-Z])/)) {
-      patterns.asyncAwait.push(file);
-    }
-    if (content.match(/\.then\(/) || content.match(/\.catch\(/)) {
-      patterns.promises.push(file);
-    }
-    if (content.match(/callback\s*\(/) || content.match(/\(\s*err\s*,/)) {
-      patterns.callbacks.push(file);
-    }
-  }
-  const issues = [];
-  if (patterns.callbacks.length > 0 && patterns.asyncAwait.length > 0) {
-    issues.push({
-      files: [...patterns.callbacks, ...patterns.asyncAwait],
-      type: "async-style",
-      description: "Mixed async patterns: callbacks and async/await",
-      examples: [
-        `Callbacks found in: ${patterns.callbacks.slice(0, 3).join(", ")}`,
-        `Async/await used in: ${patterns.asyncAwait.slice(0, 3).join(", ")}`
-      ],
-      severity: "minor"
-    });
-  }
-  if (patterns.promises.length > patterns.asyncAwait.length * 0.3 && patterns.asyncAwait.length > 0) {
-    issues.push({
-      files: patterns.promises,
-      type: "async-style",
-      description: "Consider using async/await instead of promise chains for consistency",
-      examples: patterns.promises.slice(0, 5),
-      severity: "info"
-    });
-  }
-  return issues;
-}
-async function analyzeImportStyles(files) {
-  const patterns = {
-    esModules: [],
-    commonJS: [],
-    mixed: []
-  };
-  for (const file of files) {
-    const content = await readFileContent2(file);
-    const hasESM = content.match(/^import\s+/m);
-    const hasCJS = content.match(/require\s*\(/);
-    if (hasESM && hasCJS) {
-      patterns.mixed.push(file);
-    } else if (hasESM) {
-      patterns.esModules.push(file);
-    } else if (hasCJS) {
-      patterns.commonJS.push(file);
-    }
-  }
-  const issues = [];
-  if (patterns.mixed.length > 0) {
-    issues.push({
-      files: patterns.mixed,
-      type: "import-style",
-      description: "Mixed ES modules and CommonJS imports in same files",
-      examples: patterns.mixed.slice(0, 5),
-      severity: "major"
-    });
-  }
-  if (patterns.esModules.length > 0 && patterns.commonJS.length > 0) {
-    const ratio = patterns.commonJS.length / (patterns.esModules.length + patterns.commonJS.length);
-    if (ratio > 0.2 && ratio < 0.8) {
-      issues.push({
-        files: [...patterns.esModules, ...patterns.commonJS],
-        type: "import-style",
-        description: "Inconsistent import styles across project",
-        examples: [
-          `ES modules: ${patterns.esModules.length} files`,
-          `CommonJS: ${patterns.commonJS.length} files`
-        ],
-        severity: "minor"
-      });
-    }
-  }
-  return issues;
-}
-
-// src/analyzer.ts
-import { scanFiles } from "@aiready/core";
-async function analyzeConsistency(options) {
-  const {
-    checkNaming = true,
-    checkPatterns = true,
-    checkArchitecture = false,
-    // Not implemented yet
-    minSeverity = "info",
-    ...scanOptions
-  } = options;
-  const filePaths = await scanFiles(scanOptions);
-  const namingIssues = checkNaming ? await analyzeNaming(filePaths) : [];
-  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" ? "naming-inconsistency" : "naming-quality",
-      category: "naming",
-      severity: 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: "pattern-inconsistency",
-      category: "patterns",
-      severity: 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)
-      }
-    });
-  }
-  const recommendations = generateRecommendations(namingIssues, patternIssues);
-  const conventionAnalysis = detectNamingConventions(filePaths, namingIssues);
-  return {
-    summary: {
-      totalIssues: namingIssues.length + patternIssues.length,
-      namingIssues: namingIssues.length,
-      patternIssues: patternIssues.length,
-      architectureIssues: 0,
-      filesAnalyzed: filePaths.length
-    },
-    results,
-    recommendations
-  };
-}
-function shouldIncludeSeverity(severity, minSeverity) {
-  const severityLevels = { info: 0, minor: 1, major: 2, critical: 3 };
-  return severityLevels[severity] >= severityLevels[minSeverity];
-}
-function calculateConsistencyScore(issues) {
-  const weights = { critical: 10, major: 5, minor: 2, info: 1 };
-  const totalWeight = issues.reduce((sum, issue) => sum + weights[issue.severity], 0);
-  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 {
-  analyzeNaming,
-  detectNamingConventions,
-  analyzePatterns,
-  analyzeConsistency
-};