@aiready/cli 0.14.1 → 0.14.3

package/src/commands/shared/standard-tool-actions.ts

@@ -0,0 +1,126 @@
+/**
+ * Shared implementations for standard config-driven CLI actions.
+ */
+
+import chalk from 'chalk';
+import type { ToolScoringOutput } from '@aiready/core';
+import { buildToolScoringOutput } from '../../utils/helpers';
+import { runConfiguredToolAction } from './configured-tool-action';
+
+export async function docDriftAction(
+  directory: string,
+  options: any
+): Promise<ToolScoringOutput | undefined> {
+  const { analyzeDocDrift } = await import('@aiready/doc-drift');
+
+  return runConfiguredToolAction(directory, options, {
+    defaults: { staleMonths: 6 },
+    analyze: analyzeDocDrift as any,
+    getExtras: (cmdOptions, merged) => ({
+      staleMonths: cmdOptions.staleMonths ?? merged.staleMonths ?? 6,
+    }),
+    score: (toolReport): ToolScoringOutput =>
+      buildToolScoringOutput('doc-drift', toolReport as any),
+    render: (report: any, scoring) => {
+      const { summary } = report;
+      const ratingColors: Record<string, (s: string) => string> = {
+        minimal: chalk.green,
+        low: chalk.cyan,
+        moderate: chalk.yellow,
+        high: chalk.red,
+        severe: chalk.bgRed.white,
+      };
+      const color = ratingColors[summary.rating] ?? chalk.white;
+      console.log(
+        `  📝 Documentation Drift:  ${chalk.bold(100 - scoring.score + '/100 health')} (${color(summary.rating)} risk)`
+      );
+      if (report.issues.length > 0) {
+        console.log(
+          chalk.dim(`     Found ${report.issues.length} drift issues.`)
+        );
+      } else {
+        console.log(chalk.dim(`     No documentation drift detected.`));
+      }
+    },
+  });
+}
+
+export async function depsHealthAction(
+  directory: string,
+  options: any
+): Promise<ToolScoringOutput | undefined> {
+  const { analyzeDeps } = await import('@aiready/deps');
+
+  return runConfiguredToolAction(directory, options, {
+    defaults: { trainingCutoffYear: 2023 },
+    analyze: analyzeDeps as any,
+    getExtras: (cmdOptions, merged) => ({
+      trainingCutoffYear:
+        cmdOptions.trainingCutoffYear ?? merged.trainingCutoffYear ?? 2023,
+    }),
+    score: (toolReport): ToolScoringOutput =>
+      buildToolScoringOutput('dependency-health', toolReport as any),
+    render: (report: any, scoring) => {
+      const { summary } = report;
+      const ratingColors: Record<string, (s: string) => string> = {
+        excellent: chalk.green,
+        good: chalk.blueBright,
+        moderate: chalk.yellow,
+        poor: chalk.red,
+        hazardous: chalk.bgRed.white,
+      };
+      const color = ratingColors[summary.rating] ?? chalk.white;
+      console.log(
+        `  📦 Dependency Health:  ${chalk.bold(scoring.score + '/100 health')} (${color(summary.rating)})`
+      );
+      if (report.issues.length > 0) {
+        console.log(
+          chalk.dim(`     Found ${report.issues.length} dependency issues.`)
+        );
+      } else {
+        console.log(
+          chalk.dim(`     Dependencies look healthy for AI assistance.`)
+        );
+      }
+    },
+  });
+}
+
+export async function aiSignalClarityAction(
+  directory: string,
+  options: any
+): Promise<ToolScoringOutput | undefined> {
+  const { analyzeAiSignalClarity, calculateAiSignalClarityScore } =
+    await import('@aiready/ai-signal-clarity');
+
+  return runConfiguredToolAction(directory, options, {
+    defaults: { minSeverity: 'info' },
+    analyze: analyzeAiSignalClarity as any,
+    getExtras: (cmdOptions, merged) => ({
+      minSeverity: cmdOptions.minSeverity ?? merged.minSeverity ?? 'info',
+    }),
+    score: (toolReport) => calculateAiSignalClarityScore(toolReport as any),
+    render: (report: any, scoring) => {
+      const { summary } = report;
+      const ratingColors: Record<string, (s: string) => string> = {
+        minimal: chalk.green,
+        low: chalk.cyan,
+        moderate: chalk.yellow,
+        high: chalk.red,
+        severe: chalk.bgRed.white,
+      };
+      const color = ratingColors[summary.rating] ?? chalk.white;
+      console.log(
+        `  🧠 AI Signal Clarity:  ${chalk.bold(scoring.score + '/100')} (${color(summary.rating)})`
+      );
+      console.log(`     Top Risk: ${chalk.italic(summary.topRisk)}`);
+      if (summary.totalSignals > 0) {
+        console.log(
+          chalk.dim(
+            `     ${summary.criticalSignals} critical  ${summary.majorSignals} major  ${summary.minorSignals} minor signals`
+          )
+        );
+      }
+    },
+  });
+}

package/src/commands/visualize.ts

@@ -7,8 +7,7 @@ import { writeFileSync, readFileSync, existsSync, copyFileSync } from 'fs';
 import { resolve as resolvePath } from 'path';
 import { spawn } from 'child_process';
 import { handleCLIError } from '@aiready/core';
-import { generateHTML } from '@aiready/core';
-import { findLatestScanReport } from '../utils/helpers';
+import { generateHTML, findLatestReport } from '@aiready/core';
 
 interface VisualizeOptions {
   report?: string;
@@ -30,7 +29,7 @@ export async function visualizeAction(
 
     // If report not provided or not found, try to find latest scan report
     if (!reportPath || !existsSync(reportPath)) {
-      const latestScan = findLatestScanReport(dirPath);
+      const latestScan = findLatestReport(dirPath);
       if (latestScan) {
         reportPath = latestScan;
         console.log(

package/src/utils/helpers.ts

@@ -5,6 +5,11 @@
 import { resolve as resolvePath } from 'path';
 import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import chalk from 'chalk';
+import { loadConfig, mergeConfigWithDefaults } from '@aiready/core';
+import type { ToolScoringOutput } from '@aiready/core';
+
+// Re-export findLatestReport from core for deduplication with visualizer
+export { findLatestReport } from '@aiready/core';
 
 /**
  * Generate timestamp for report filenames (YYYYMMDD-HHMMSS)
@@ -16,42 +21,6 @@ export function getReportTimestamp(): string {
   return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
 }
 
-/**
- * Find the latest aiready report in the .aiready directory
- * Searches for both new format (aiready-report-*) and legacy format (aiready-scan-*)
- */
-export function findLatestScanReport(dirPath: string): string | null {
-  const aireadyDir = resolvePath(dirPath, '.aiready');
-  if (!existsSync(aireadyDir)) {
-    return null;
-  }
-
-  // Search for new format first, then legacy format
-  let files = readdirSync(aireadyDir).filter(
-    (f) => f.startsWith('aiready-report-') && f.endsWith('.json')
-  );
-  if (files.length === 0) {
-    files = readdirSync(aireadyDir).filter(
-      (f) => f.startsWith('aiready-scan-') && f.endsWith('.json')
-    );
-  }
-
-  if (files.length === 0) {
-    return null;
-  }
-
-  // Sort by modification time, most recent first
-  const sortedFiles = files
-    .map((f) => ({
-      name: f,
-      path: resolvePath(aireadyDir, f),
-      mtime: statSync(resolvePath(aireadyDir, f)).mtime,
-    }))
-    .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-
-  return sortedFiles[0].path;
-}
-
 /**
  * Warn if graph caps may be exceeded
  */
@@ -156,3 +125,83 @@ export function truncateArray(arr: any[] | undefined, cap = 8): string {
   const more = arr.length - shown.length;
   return shown.join(', ') + (more > 0 ? `, ... (+${more} more)` : '');
 }
+
+/**
+ * Build a common ToolScoringOutput payload from a tool report.
+ */
+export function buildToolScoringOutput(
+  toolName: string,
+  report: {
+    summary: { score: number };
+    rawData?: Record<string, unknown>;
+    recommendations?: string[];
+  }
+): ToolScoringOutput {
+  return {
+    toolName,
+    score: report.summary.score,
+    rawMetrics: report.rawData ?? {},
+    factors: [],
+    recommendations: (report.recommendations ?? []).map((action: string) => ({
+      action,
+      estimatedImpact: 5,
+      priority: 'medium',
+    })),
+  };
+}
+
+/**
+ * Load config and apply tool-level defaults.
+ */
+export async function loadMergedToolConfig<T extends Record<string, unknown>>(
+  directory: string,
+  defaults: T
+): Promise<T & Record<string, unknown>> {
+  const config = await loadConfig(directory);
+  return mergeConfigWithDefaults(config, defaults) as T &
+    Record<string, unknown>;
+}
+
+/**
+ * Shared base scan options used by CLI tool commands.
+ */
+export function buildCommonScanOptions(
+  directory: string,
+  options: any,
+  extras: Record<string, unknown> = {}
+): Record<string, unknown> {
+  return {
+    rootDir: directory,
+    include: options.include,
+    exclude: options.exclude,
+    ...extras,
+  };
+}
+
+/**
+ * Execute a config-driven tool command with shared CLI plumbing.
+ */
+export async function runConfiguredToolCommand<TReport, TScoring>(params: {
+  directory: string;
+  options: any;
+  defaults: Record<string, unknown>;
+  analyze: (scanOptions: any) => Promise<TReport>;
+  getExtras: (
+    options: any,
+    merged: Record<string, unknown>
+  ) => Record<string, unknown>;
+  score: (report: TReport) => TScoring;
+}): Promise<{ report: TReport; scoring: TScoring }> {
+  const merged = await loadMergedToolConfig(params.directory, params.defaults);
+  const report = await params.analyze(
+    buildCommonScanOptions(
+      params.directory,
+      params.options,
+      params.getExtras(params.options, merged)
+    )
+  );
+  return {
+    report,
+    scoring: params.score(report),
+  };
+}

package/vitest.config.ts

@@ -1,20 +1,13 @@
 import { defineConfig } from 'vitest/config';
-import { resolve } from 'path';
+import { createAireadyVitestAliases } from '../../vitest-aliases';
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    alias: {
-      '@aiready/core': resolve(__dirname, '../core/src/index.ts'),
-      '@aiready/pattern-detect': resolve(
-        __dirname,
-        '../pattern-detect/src/index.ts'
-      ),
-      '@aiready/context-analyzer': resolve(
-        __dirname,
-        '../context-analyzer/src/index.ts'
-      ),
-    },
+    alias: createAireadyVitestAliases(__dirname, {
+      packagesRootRelative: '..',
+      useIndexEntrypoints: true,
+    }),
   },
 });