@aiready/consistency 0.2.0

package/dist/cli.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/analyzer.ts
+var import_core3 = require("@aiready/core");
+
+// src/analyzers/naming.ts
+var import_core = require("@aiready/core");
+async function analyzeNaming(files) {
+  const issues = [];
+  for (const file of files) {
+    const content = await (0, import_core.readFileContent)(file);
+    const fileIssues = analyzeFileNaming(file, content);
+    issues.push(...fileIssues);
+  }
+  return issues;
+}
+function analyzeFileNaming(file, content) {
+  const issues = [];
+  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) {
+      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];
+      if (!["id", "url", "api", "db", "fs", "os", "ui"].includes(abbrev.toLowerCase())) {
+        issues.push({
+          file,
+          line: lineNumber,
+          type: "abbreviation",
+          identifier: abbrev,
+          severity: "info",
+          suggestion: `Consider using full word instead of abbreviation '${abbrev}'`
+        });
+      }
+    }
+    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];
+      if (!name.match(/^(get|set|is|has|can|should|create|update|delete|fetch|load|save|process|handle|validate|check|find|search|filter|map|reduce)/)) {
+        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
+var import_core2 = require("@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 (0, import_core2.readFileContent)(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 (0, import_core2.readFileContent)(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 (0, import_core2.readFileContent)(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
+async function analyzeConsistency(options) {
+  const {
+    checkNaming = true,
+    checkPatterns = true,
+    checkArchitecture = false,
+    // Not implemented yet
+    minSeverity = "info",
+    ...scanOptions
+  } = options;
+  const filePaths = await (0, import_core3.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;
+}
+
+// src/cli.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs = require("fs");
+var import_core4 = require("@aiready/core");
+var program = new import_commander.Command();
+program.name("aiready-consistency").description("Detect consistency issues in naming, patterns, and architecture").version("0.1.0").addHelpText("after", `
+CONFIGURATION:
+  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json
+  CLI options override config file settings
+
+ANALYSIS CATEGORIES:
+  --naming         Check naming conventions and quality (default: enabled)
+  --patterns       Check code pattern consistency (default: enabled)
+  --architecture   Check architectural consistency (coming soon)
+
+EXAMPLES:
+  aiready-consistency .                               # Full analysis
+  aiready-consistency . --no-naming                   # Skip naming checks
+  aiready-consistency . --min-severity major          # Only show major+ issues
+  aiready-consistency . --output json > report.json   # JSON export
+`).argument("<directory>", "Directory to analyze").option("--naming", "Check naming conventions and quality (default: true)").option("--no-naming", "Skip naming analysis").option("--patterns", "Check code pattern consistency (default: true)").option("--no-patterns", "Skip pattern analysis").option("--architecture", "Check architectural consistency (not yet implemented)").option("--min-severity <level>", "Minimum severity: info|minor|major|critical. Default: info").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option("-o, --output <format>", "Output format: console|json|markdown", "console").option("--output-file <path>", "Output file path (for json/markdown)").action(async (directory, options) => {
+  console.log(import_chalk.default.blue("\u{1F50D} Analyzing consistency...\n"));
+  const startTime = Date.now();
+  const config = (0, import_core4.loadConfig)(directory);
+  const defaults = {
+    checkNaming: true,
+    checkPatterns: true,
+    checkArchitecture: false,
+    minSeverity: "info",
+    include: void 0,
+    exclude: void 0
+  };
+  const mergedConfig = (0, import_core4.mergeConfigWithDefaults)(config, defaults);
+  const finalOptions = {
+    rootDir: directory,
+    checkNaming: options.naming !== false && mergedConfig.checkNaming,
+    checkPatterns: options.patterns !== false && mergedConfig.checkPatterns,
+    checkArchitecture: options.architecture || mergedConfig.checkArchitecture,
+    minSeverity: options.minSeverity || mergedConfig.minSeverity,
+    include: options.include?.split(",") || mergedConfig.include,
+    exclude: options.exclude?.split(",") || mergedConfig.exclude
+  };
+  const report = await analyzeConsistency(finalOptions);
+  const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+  if (options.output === "json") {
+    const output = JSON.stringify(report, null, 2);
+    if (options.outputFile) {
+      (0, import_fs.writeFileSync)(options.outputFile, output);
+      console.log(import_chalk.default.green(`\u2713 Report saved to ${options.outputFile}`));
+    } else {
+      console.log(output);
+    }
+  } else if (options.output === "markdown") {
+    const markdown = generateMarkdownReport(report, elapsedTime);
+    if (options.outputFile) {
+      (0, import_fs.writeFileSync)(options.outputFile, markdown);
+      console.log(import_chalk.default.green(`\u2713 Report saved to ${options.outputFile}`));
+    } else {
+      console.log(markdown);
+    }
+  } else {
+    displayConsoleReport(report, elapsedTime);
+  }
+});
+program.parse();
+function displayConsoleReport(report, elapsedTime) {
+  const { summary, results, recommendations } = report;
+  console.log(import_chalk.default.bold("\n\u{1F4CA} Summary\n"));
+  console.log(`Files Analyzed: ${import_chalk.default.cyan(summary.filesAnalyzed)}`);
+  console.log(`Total Issues: ${import_chalk.default.yellow(summary.totalIssues)}`);
+  console.log(`  Naming: ${import_chalk.default.yellow(summary.namingIssues)}`);
+  console.log(`  Patterns: ${import_chalk.default.yellow(summary.patternIssues)}`);
+  console.log(`  Architecture: ${import_chalk.default.yellow(summary.architectureIssues)}`);
+  console.log(`Analysis Time: ${import_chalk.default.gray(elapsedTime + "s")}
+`);
+  if (summary.totalIssues === 0) {
+    console.log(import_chalk.default.green("\u2728 No consistency issues found! Your codebase is well-maintained.\n"));
+    return;
+  }
+  const namingResults = results.filter(
+    (r) => r.issues.some((i) => i.category === "naming")
+  );
+  const patternResults = results.filter(
+    (r) => r.issues.some((i) => i.category === "patterns")
+  );
+  if (namingResults.length > 0) {
+    console.log(import_chalk.default.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
+    displayCategoryIssues(namingResults, 5);
+  }
+  if (patternResults.length > 0) {
+    console.log(import_chalk.default.bold("\n\u{1F504} Pattern Issues\n"));
+    displayCategoryIssues(patternResults, 5);
+  }
+  console.log(import_chalk.default.bold("\n\u{1F4A1} Recommendations\n"));
+  recommendations.forEach((rec, i) => {
+    console.log(`${i + 1}. ${rec}`);
+  });
+  console.log();
+}
+function displayCategoryIssues(results, maxToShow) {
+  let shown = 0;
+  for (const result of results) {
+    if (shown >= maxToShow) break;
+    for (const issue of result.issues) {
+      if (shown >= maxToShow) break;
+      const severityColor = issue.severity === "critical" ? import_chalk.default.red : issue.severity === "major" ? import_chalk.default.yellow : issue.severity === "minor" ? import_chalk.default.blue : import_chalk.default.gray;
+      console.log(
+        `${severityColor(issue.severity.toUpperCase())} ${import_chalk.default.dim(
+          `${issue.location.file}:${issue.location.line}`
+        )}`
+      );
+      console.log(`  ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(`  ${import_chalk.default.dim("\u2192")} ${import_chalk.default.italic(issue.suggestion)}`);
+      }
+      console.log();
+      shown++;
+    }
+  }
+  const remaining = results.reduce((sum, r) => sum + r.issues.length, 0) - shown;
+  if (remaining > 0) {
+    console.log(import_chalk.default.dim(`  ... and ${remaining} more issues
+`));
+  }
+}
+function generateMarkdownReport(report, elapsedTime) {
+  const { summary, results, recommendations } = report;
+  let markdown = `# Consistency Analysis Report
+
+`;
+  markdown += `**Generated:** ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  markdown += `**Analysis Time:** ${elapsedTime}s
+
+`;
+  markdown += `## Summary
+
+`;
+  markdown += `- **Files Analyzed:** ${summary.filesAnalyzed}
+`;
+  markdown += `- **Total Issues:** ${summary.totalIssues}
+`;
+  markdown += `  - Naming: ${summary.namingIssues}
+`;
+  markdown += `  - Patterns: ${summary.patternIssues}
+`;
+  markdown += `  - Architecture: ${summary.architectureIssues}
+
+`;
+  if (summary.totalIssues === 0) {
+    markdown += `\u2728 No consistency issues found!
+`;
+    return markdown;
+  }
+  markdown += `## Issues by Category
+
+`;
+  const namingResults = results.filter(
+    (r) => r.issues.some((i) => i.category === "naming")
+  );
+  if (namingResults.length > 0) {
+    markdown += `### \u{1F3F7}\uFE0F Naming Issues
+
+`;
+    for (const result of namingResults) {
+      for (const issue of result.issues) {
+        if (issue.category !== "naming") continue;
+        markdown += `- **${issue.severity.toUpperCase()}** \`${issue.location.file}:${issue.location.line}\`
+`;
+        markdown += `  - ${issue.message}
+`;
+        if (issue.suggestion) {
+          markdown += `  - \u{1F4A1} ${issue.suggestion}
+`;
+        }
+      }
+    }
+    markdown += `
+`;
+  }
+  const patternResults = results.filter(
+    (r) => r.issues.some((i) => i.category === "patterns")
+  );
+  if (patternResults.length > 0) {
+    markdown += `### \u{1F504} Pattern Issues
+
+`;
+    for (const result of patternResults) {
+      for (const issue of result.issues) {
+        if (issue.category !== "patterns") continue;
+        markdown += `- **${issue.severity.toUpperCase()}** ${issue.message}
+`;
+        if (issue.examples && issue.examples.length > 0) {
+          markdown += `  - Examples:
+`;
+          issue.examples.forEach((ex) => {
+            markdown += `    - ${ex}
+`;
+          });
+        }
+        if (issue.suggestion) {
+          markdown += `  - \u{1F4A1} ${issue.suggestion}
+`;
+        }
+      }
+    }
+    markdown += `
+`;
+  }
+  markdown += `## Recommendations
+
+`;
+  recommendations.forEach((rec, i) => {
+    markdown += `${i + 1}. ${rec}
+`;
+  });
+  return markdown;
+}