@aiready/consistency 0.2.0

package/src/cli.ts

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { analyzeConsistency } from './analyzer';
+import type { ConsistencyOptions } from './types';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, mergeConfigWithDefaults } from '@aiready/core';
+
+const 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('🔍 Analyzing consistency...\n'));
+
+    const startTime = Date.now();
+
+    // Load config file if it exists
+    const config = loadConfig(directory);
+
+    // Define defaults
+    const defaults = {
+      checkNaming: true,
+      checkPatterns: true,
+      checkArchitecture: false,
+      minSeverity: 'info' as const,
+      include: undefined,
+      exclude: undefined,
+    };
+
+    // Merge config with defaults
+    const mergedConfig = mergeConfigWithDefaults(config, defaults);
+
+    // Override with CLI options (CLI takes precedence)
+    const finalOptions: ConsistencyOptions = {
+      rootDir: directory,
+      checkNaming: options.naming !== false && mergedConfig.checkNaming,
+      checkPatterns: options.patterns !== false && mergedConfig.checkPatterns,
+      checkArchitecture: options.architecture || mergedConfig.checkArchitecture,
+      minSeverity: (options.minSeverity as any) || mergedConfig.minSeverity,
+      include: options.include?.split(',') || mergedConfig.include,
+      exclude: options.exclude?.split(',') || mergedConfig.exclude,
+    };
+
+    const report = await analyzeConsistency(finalOptions);
+
+    const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    // Output based on format
+    if (options.output === 'json') {
+      const output = JSON.stringify(report, null, 2);
+      if (options.outputFile) {
+        writeFileSync(options.outputFile, output);
+        console.log(chalk.green(`✓ 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(`✓ Report saved to ${options.outputFile}`));
+      } else {
+        console.log(markdown);
+      }
+    } else {
+      // Console output
+      displayConsoleReport(report, elapsedTime);
+    }
+  });
+
+program.parse();
+
+function displayConsoleReport(report: any, elapsedTime: string): void {
+  const { summary, results, recommendations } = report;
+
+  console.log(chalk.bold('\n📊 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')}\n`);
+
+  if (summary.totalIssues === 0) {
+    console.log(chalk.green('✨ No consistency issues found! Your codebase is well-maintained.\n'));
+    return;
+  }
+
+  // Group issues by category
+  const namingResults = results.filter((r: any) =>
+    r.issues.some((i: any) => i.category === 'naming')
+  );
+  const patternResults = results.filter((r: any) =>
+    r.issues.some((i: any) => i.category === 'patterns')
+  );
+
+  if (namingResults.length > 0) {
+    console.log(chalk.bold('🏷️  Naming Issues\n'));
+    displayCategoryIssues(namingResults, 5);
+  }
+
+  if (patternResults.length > 0) {
+    console.log(chalk.bold('\n🔄 Pattern Issues\n'));
+    displayCategoryIssues(patternResults, 5);
+  }
+
+  console.log(chalk.bold('\n💡 Recommendations\n'));
+  recommendations.forEach((rec: string, i: number) => {
+    console.log(`${i + 1}. ${rec}`);
+  });
+
+  console.log();
+}
+
+function displayCategoryIssues(results: any[], maxToShow: number): void {
+  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('→')} ${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\n`));
+  }
+}
+
+function generateMarkdownReport(report: any, elapsedTime: string): string {
+  const { summary, results, recommendations } = report;
+
+  let markdown = `# Consistency Analysis Report\n\n`;
+  markdown += `**Generated:** ${new Date().toISOString()}\n`;
+  markdown += `**Analysis Time:** ${elapsedTime}s\n\n`;
+
+  markdown += `## Summary\n\n`;
+  markdown += `- **Files Analyzed:** ${summary.filesAnalyzed}\n`;
+  markdown += `- **Total Issues:** ${summary.totalIssues}\n`;
+  markdown += `  - Naming: ${summary.namingIssues}\n`;
+  markdown += `  - Patterns: ${summary.patternIssues}\n`;
+  markdown += `  - Architecture: ${summary.architectureIssues}\n\n`;
+
+  if (summary.totalIssues === 0) {
+    markdown += `✨ No consistency issues found!\n`;
+    return markdown;
+  }
+
+  markdown += `## Issues by Category\n\n`;
+
+  // Naming issues
+  const namingResults = results.filter((r: any) =>
+    r.issues.some((i: any) => i.category === 'naming')
+  );
+  if (namingResults.length > 0) {
+    markdown += `### 🏷️ Naming Issues\n\n`;
+    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}\`\n`;
+        markdown += `  - ${issue.message}\n`;
+        if (issue.suggestion) {
+          markdown += `  - 💡 ${issue.suggestion}\n`;
+        }
+      }
+    }
+    markdown += `\n`;
+  }
+
+  // Pattern issues
+  const patternResults = results.filter((r: any) =>
+    r.issues.some((i: any) => i.category === 'patterns')
+  );
+  if (patternResults.length > 0) {
+    markdown += `### 🔄 Pattern Issues\n\n`;
+    for (const result of patternResults) {
+      for (const issue of result.issues) {
+        if (issue.category !== 'patterns') continue;
+        markdown += `- **${issue.severity.toUpperCase()}** ${issue.message}\n`;
+        if (issue.examples && issue.examples.length > 0) {
+          markdown += `  - Examples:\n`;
+          issue.examples.forEach((ex: string) => {
+            markdown += `    - ${ex}\n`;
+          });
+        }
+        if (issue.suggestion) {
+          markdown += `  - 💡 ${issue.suggestion}\n`;
+        }
+      }
+    }
+    markdown += `\n`;
+  }
+
+  markdown += `## Recommendations\n\n`;
+  recommendations.forEach((rec: string, i: number) => {
+    markdown += `${i + 1}. ${rec}\n`;
+  });
+
+  return markdown;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { analyzeConsistency } from './analyzer';
+export { analyzeNaming, detectNamingConventions } from './analyzers/naming';
+export { analyzePatterns } from './analyzers/patterns';
+export type {
+  ConsistencyOptions,
+  ConsistencyReport,
+  ConsistencyIssue,
+  NamingIssue,
+  PatternIssue,
+  ArchitectureIssue,
+} from './types';

package/src/types.ts

@@ -0,0 +1,62 @@
+import type { ScanOptions, AnalysisResult, Issue } from '@aiready/core';
+
+export 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';
+}
+
+export 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;
+}
+
+export interface NamingIssue {
+  file: string;
+  line: number;
+  column?: number;
+  type: 'poor-naming' | 'convention-mix' | 'abbreviation' | 'unclear';
+  identifier: string;
+  suggestion?: string;
+  severity: 'critical' | 'major' | 'minor' | 'info';
+}
+
+export interface PatternIssue {
+  files: string[];
+  type: 'error-handling' | 'async-style' | 'import-style' | 'api-design';
+  description: string;
+  examples: string[];
+  severity: 'critical' | 'major' | 'minor' | 'info';
+}
+
+export interface ArchitectureIssue {
+  type: 'file-organization' | 'module-structure' | 'export-style';
+  description: string;
+  affectedPaths: string[];
+  severity: 'critical' | 'major' | 'minor' | 'info';
+}
+
+export interface ConsistencyReport {
+  summary: {
+    totalIssues: number;
+    namingIssues: number;
+    patternIssues: number;
+    architectureIssues: number;
+    filesAnalyzed: number;
+  };
+  results: AnalysisResult[];
+  recommendations: string[];
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../core/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}