@aiready/consistency 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import {
+  analyzeConsistency
+} from "./chunk-CF4LU7KE.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync } from "fs";
+import { loadConfig, mergeConfigWithDefaults } from "@aiready/core";
+var program = new 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(chalk.blue("\u{1F50D} Analyzing consistency...\n"));
+  const startTime = Date.now();
+  const config = loadConfig(directory);
+  const defaults = {
+    checkNaming: true,
+    checkPatterns: true,
+    checkArchitecture: false,
+    minSeverity: "info",
+    include: void 0,
+    exclude: void 0
+  };
+  const mergedConfig = 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) {
+      writeFileSync(options.outputFile, output);
+      console.log(chalk.green(`\u2713 Report saved to ${options.outputFile}`));
+    } else {
+      console.log(output);
+    }
+  } else if (options.output === "markdown") {
+    const markdown = generateMarkdownReport(report, elapsedTime);
+    if (options.outputFile) {
+      writeFileSync(options.outputFile, markdown);
+      console.log(chalk.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(chalk.bold("\n\u{1F4CA} Summary\n"));
+  console.log(`Files Analyzed: ${chalk.cyan(summary.filesAnalyzed)}`);
+  console.log(`Total Issues: ${chalk.yellow(summary.totalIssues)}`);
+  console.log(`  Naming: ${chalk.yellow(summary.namingIssues)}`);
+  console.log(`  Patterns: ${chalk.yellow(summary.patternIssues)}`);
+  console.log(`  Architecture: ${chalk.yellow(summary.architectureIssues)}`);
+  console.log(`Analysis Time: ${chalk.gray(elapsedTime + "s")}
+`);
+  if (summary.totalIssues === 0) {
+    console.log(chalk.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(chalk.bold("\u{1F3F7}\uFE0F  Naming Issues\n"));
+    displayCategoryIssues(namingResults, 5);
+  }
+  if (patternResults.length > 0) {
+    console.log(chalk.bold("\n\u{1F504} Pattern Issues\n"));
+    displayCategoryIssues(patternResults, 5);
+  }
+  console.log(chalk.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" ? chalk.red : issue.severity === "major" ? chalk.yellow : issue.severity === "minor" ? chalk.blue : chalk.gray;
+      console.log(
+        `${severityColor(issue.severity.toUpperCase())} ${chalk.dim(
+          `${issue.location.file}:${issue.location.line}`
+        )}`
+      );
+      console.log(`  ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(`  ${chalk.dim("\u2192")} ${chalk.italic(issue.suggestion)}`);
+      }
+      console.log();
+      shown++;
+    }
+  }
+  const remaining = results.reduce((sum, r) => sum + r.issues.length, 0) - shown;
+  if (remaining > 0) {
+    console.log(chalk.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;
+}

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+
+interface ConsistencyOptions extends ScanOptions {
+    /** Check naming conventions and quality */
+    checkNaming?: boolean;
+    /** Check code pattern consistency */
+    checkPatterns?: boolean;
+    /** Check architectural consistency */
+    checkArchitecture?: boolean;
+    /** Minimum severity to report */
+    minSeverity?: 'info' | 'minor' | 'major' | 'critical';
+}
+interface ConsistencyIssue extends Issue {
+    type: 'naming-inconsistency' | 'naming-quality' | 'pattern-inconsistency' | 'architecture-inconsistency';
+    category: 'naming' | 'patterns' | 'architecture';
+    /** Examples of the inconsistency found */
+    examples?: string[];
+    /** Suggested fix or convention to follow */
+    suggestion?: string;
+}
+interface NamingIssue {
+    file: string;
+    line: number;
+    column?: number;
+    type: 'poor-naming' | 'convention-mix' | 'abbreviation' | 'unclear';
+    identifier: string;
+    suggestion?: string;
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface PatternIssue {
+    files: string[];
+    type: 'error-handling' | 'async-style' | 'import-style' | 'api-design';
+    description: string;
+    examples: string[];
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface ArchitectureIssue {
+    type: 'file-organization' | 'module-structure' | 'export-style';
+    description: string;
+    affectedPaths: string[];
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface ConsistencyReport {
+    summary: {
+        totalIssues: number;
+        namingIssues: number;
+        patternIssues: number;
+        architectureIssues: number;
+        filesAnalyzed: number;
+    };
+    results: AnalysisResult[];
+    recommendations: string[];
+}
+
+/**
+ * Main consistency analyzer that orchestrates all analysis types
+ */
+declare function analyzeConsistency(options: ConsistencyOptions): Promise<ConsistencyReport>;
+
+/**
+ * Analyzes naming conventions and quality
+ */
+declare function analyzeNaming(files: string[]): Promise<NamingIssue[]>;
+/**
+ * Detects naming convention patterns across the codebase
+ */
+declare function detectNamingConventions(files: string[], allIssues: NamingIssue[]): {
+    dominantConvention: 'camelCase' | 'snake_case' | 'PascalCase' | 'mixed';
+    conventionScore: number;
+};
+
+/**
+ * Analyzes code pattern consistency
+ */
+declare function analyzePatterns(files: string[]): Promise<PatternIssue[]>;
+
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzePatterns, detectNamingConventions };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+
+interface ConsistencyOptions extends ScanOptions {
+    /** Check naming conventions and quality */
+    checkNaming?: boolean;
+    /** Check code pattern consistency */
+    checkPatterns?: boolean;
+    /** Check architectural consistency */
+    checkArchitecture?: boolean;
+    /** Minimum severity to report */
+    minSeverity?: 'info' | 'minor' | 'major' | 'critical';
+}
+interface ConsistencyIssue extends Issue {
+    type: 'naming-inconsistency' | 'naming-quality' | 'pattern-inconsistency' | 'architecture-inconsistency';
+    category: 'naming' | 'patterns' | 'architecture';
+    /** Examples of the inconsistency found */
+    examples?: string[];
+    /** Suggested fix or convention to follow */
+    suggestion?: string;
+}
+interface NamingIssue {
+    file: string;
+    line: number;
+    column?: number;
+    type: 'poor-naming' | 'convention-mix' | 'abbreviation' | 'unclear';
+    identifier: string;
+    suggestion?: string;
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface PatternIssue {
+    files: string[];
+    type: 'error-handling' | 'async-style' | 'import-style' | 'api-design';
+    description: string;
+    examples: string[];
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface ArchitectureIssue {
+    type: 'file-organization' | 'module-structure' | 'export-style';
+    description: string;
+    affectedPaths: string[];
+    severity: 'critical' | 'major' | 'minor' | 'info';
+}
+interface ConsistencyReport {
+    summary: {
+        totalIssues: number;
+        namingIssues: number;
+        patternIssues: number;
+        architectureIssues: number;
+        filesAnalyzed: number;
+    };
+    results: AnalysisResult[];
+    recommendations: string[];
+}
+
+/**
+ * Main consistency analyzer that orchestrates all analysis types
+ */
+declare function analyzeConsistency(options: ConsistencyOptions): Promise<ConsistencyReport>;
+
+/**
+ * Analyzes naming conventions and quality
+ */
+declare function analyzeNaming(files: string[]): Promise<NamingIssue[]>;
+/**
+ * Detects naming convention patterns across the codebase
+ */
+declare function detectNamingConventions(files: string[], allIssues: NamingIssue[]): {
+    dominantConvention: 'camelCase' | 'snake_case' | 'PascalCase' | 'mixed';
+    conventionScore: number;
+};
+
+/**
+ * Analyzes code pattern consistency
+ */
+declare function analyzePatterns(files: string[]): Promise<PatternIssue[]>;
+
+export { type ArchitectureIssue, type ConsistencyIssue, type ConsistencyOptions, type ConsistencyReport, type NamingIssue, type PatternIssue, analyzeConsistency, analyzeNaming, analyzePatterns, detectNamingConventions };