@aiready/cli 0.14.1 → 0.14.3

package/src/__tests__/config-shape.test.ts

@@ -76,7 +76,7 @@ describe('CLI Configuration Shape', () => {
       rootDir: '/test',
       tools: [ToolName.PatternDetect],
       useSmartDefaults: true,
-      // @ts-ignore - testing internal key stripping
+      // @ts-expect-error - testing internal key stripping
       batchSize: 50,
     });
 

package/src/cli.ts

@@ -132,9 +132,10 @@ program
     '--js',
     'Generate configuration as a JavaScript file (aiready.config.js)'
   )
+  .option('--full', 'Generate a full configuration with all available options')
   .action(async (options) => {
     const format = options.js ? 'js' : 'json';
-    await initAction({ force: options.force, format });
+    await initAction({ force: options.force, format, full: options.full });
   });
 
 // Patterns command - Detect duplicate code patterns

package/src/commands/__tests__/consistency.test.ts

@@ -60,6 +60,7 @@ describe('Consistency CLI Action', () => {
     consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     vi.mocked(core.loadMergedConfig).mockResolvedValue({
       output: { format: 'console' },
+      rootDir: '/test',
     });
   });
 
@@ -75,6 +76,7 @@ describe('Consistency CLI Action', () => {
   it('supports JSON output', async () => {
     vi.mocked(core.loadMergedConfig).mockResolvedValue({
       output: { format: 'json' },
+      rootDir: '/test',
     });
     await consistencyAction('.', {});
     expect(core.handleJSONOutput).toHaveBeenCalled();
@@ -83,6 +85,7 @@ describe('Consistency CLI Action', () => {
   it('supports Markdown output', async () => {
     vi.mocked(core.loadMergedConfig).mockResolvedValue({
       output: { format: 'markdown' },
+      rootDir: '/test',
     });
     await consistencyAction('.', {});
     expect(fs.writeFileSync).toHaveBeenCalled();

package/src/commands/__tests__/extra-commands.test.ts

@@ -18,7 +18,7 @@ vi.mock('@aiready/core', async () => {
       .fn()
       .mockImplementation((c, d) => ({ ...d, ...c })),
     loadMergedConfig: vi.fn().mockResolvedValue({
-      rootDir: '.',
+      rootDir: '/test',
       output: { format: 'console' },
       checkNaming: true,
       checkPatterns: true,
@@ -33,13 +33,11 @@ vi.mock('@aiready/core', async () => {
 
 // Mock all spokes
 vi.mock('@aiready/change-amplification', () => ({
-  analyzeChangeAmplification: vi
-    .fn()
-    .mockResolvedValue({
-      results: [],
-      summary: { rating: 'contained' },
-      recommendations: [],
-    }),
+  analyzeChangeAmplification: vi.fn().mockResolvedValue({
+    results: [],
+    summary: { rating: 'contained' },
+    recommendations: [],
+  }),
   calculateChangeAmplificationScore: vi.fn().mockReturnValue({ score: 80 }),
 }));
 vi.mock('@aiready/agent-grounding', () => ({
@@ -91,39 +89,33 @@ vi.mock('@aiready/deps', () => ({
   calculateDepsScore: vi.fn().mockReturnValue({ score: 80 }),
 }));
 vi.mock('@aiready/pattern-detect', () => ({
-  analyzePatterns: vi
-    .fn()
-    .mockResolvedValue({
-      results: [],
-      summary: { totalPatterns: 0 },
-      config: {},
-    }),
-  generateSummary: vi
-    .fn()
-    .mockReturnValue({
-      totalPatterns: 0,
-      totalTokenCost: 0,
-      patternsByType: {},
-      topDuplicates: [],
-    }),
+  analyzePatterns: vi.fn().mockResolvedValue({
+    results: [],
+    summary: { totalPatterns: 0 },
+    config: {},
+  }),
+  generateSummary: vi.fn().mockReturnValue({
+    totalPatterns: 0,
+    totalTokenCost: 0,
+    patternsByType: {},
+    topDuplicates: [],
+  }),
   getSmartDefaults: vi.fn().mockResolvedValue({}),
 }));
 vi.mock('@aiready/context-analyzer', () => ({
   analyzeContext: vi.fn().mockResolvedValue([]),
-  generateSummary: vi
-    .fn()
-    .mockReturnValue({
-      score: 80,
-      rating: 'good',
-      totalFiles: 0,
-      totalTokens: 0,
-      avgImportDepth: 0,
-      maxImportDepth: 0,
-      avgFragmentation: 0,
-      criticalIssues: 0,
-      majorIssues: 0,
-      totalPotentialSavings: 0,
-    }),
+  generateSummary: vi.fn().mockReturnValue({
+    score: 80,
+    rating: 'good',
+    totalFiles: 0,
+    totalTokens: 0,
+    avgImportDepth: 0,
+    maxImportDepth: 0,
+    avgFragmentation: 0,
+    criticalIssues: 0,
+    majorIssues: 0,
+    totalPotentialSavings: 0,
+  }),
   getSmartDefaults: vi.fn().mockResolvedValue({}),
 }));
 

package/src/commands/__tests__/scan.test.ts

@@ -58,6 +58,7 @@ describe('Scan CLI Action', () => {
     vi.mocked(core.loadMergedConfig).mockResolvedValue({
       tools: ['pattern-detect'],
       output: { format: 'console' },
+      rootDir: '/test',
     });
     vi.mocked(index.analyzeUnified).mockResolvedValue({
       summary: {
@@ -126,7 +127,7 @@ describe('Scan CLI Action', () => {
 
     expect(exitSpy).toHaveBeenCalledWith(1);
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('PR BLOCKED')
+      expect.stringContaining('SCAN FAILED')
     );
     // Verify annotations are emitted
     expect(consoleSpy).toHaveBeenCalledWith(
@@ -144,6 +145,7 @@ describe('Scan CLI Action', () => {
     vi.mocked(core.loadMergedConfig).mockResolvedValue({
       tools: ['pattern-detect'],
       output: { format: 'json', file: 'out.json' },
+      rootDir: '/test',
     });
     await scanAction('.', {});
     expect(core.handleJSONOutput).toHaveBeenCalled();

package/src/commands/__tests__/visualize.test.ts

@@ -2,7 +2,6 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { visualizeAction } from '../visualize';
 import * as fs from 'fs';
 import * as core from '@aiready/core';
-import * as helpers from '../../utils/helpers';
 import { spawn } from 'child_process';
 
 vi.mock('fs', async () => {
@@ -29,10 +28,7 @@ vi.mock('@aiready/visualizer/graph', () => ({
 vi.mock('@aiready/core', () => ({
   handleCLIError: vi.fn(),
   generateHTML: vi.fn().mockReturnValue('<html></html>'),
-}));
-
-vi.mock('../../utils/helpers', () => ({
-  findLatestScanReport: vi.fn(),
+  findLatestReport: vi.fn(),
 }));
 
 describe('Visualize CLI Action', () => {
@@ -54,7 +50,7 @@ describe('Visualize CLI Action', () => {
   });
 
   it('should find latest report if none specified', async () => {
-    vi.spyOn(helpers, 'findLatestScanReport').mockReturnValue('latest.json');
+    vi.mocked(core.findLatestReport).mockReturnValue('latest.json');
     await visualizeAction('.', {});
     expect(fs.readFileSync).toHaveBeenCalledWith(
       expect.stringContaining('latest.json'),
@@ -64,7 +60,7 @@ describe('Visualize CLI Action', () => {
 
   it('should handle missing reports', async () => {
     vi.spyOn(fs, 'existsSync').mockReturnValue(false);
-    vi.spyOn(helpers, 'findLatestScanReport').mockReturnValue(null);
+    vi.mocked(core.findLatestReport).mockReturnValue(null);
     const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
     await visualizeAction('.', { report: 'missing.json' });

package/src/commands/ai-signal-clarity.ts

@@ -1,56 +1 @@
-/**
- * AI signal clarity command for unified CLI
- */
-
-import chalk from 'chalk';
-import { loadConfig, mergeConfigWithDefaults } from '@aiready/core';
-import type { ToolScoringOutput } from '@aiready/core';
-
-export async function aiSignalClarityAction(
-  directory: string,
-  options: any
-): Promise<ToolScoringOutput | undefined> {
-  const { analyzeAiSignalClarity, calculateAiSignalClarityScore } =
-    await import('@aiready/ai-signal-clarity');
-
-  const config = await loadConfig(directory);
-  const merged = mergeConfigWithDefaults(config, {
-    minSeverity: 'info',
-  });
-
-  const report = await analyzeAiSignalClarity({
-    rootDir: directory,
-    minSeverity: options.minSeverity ?? merged.minSeverity ?? 'info',
-    include: options.include,
-    exclude: options.exclude,
-  });
-
-  const scoring = calculateAiSignalClarityScore(report);
-
-  if (options.output === 'json') {
-    return 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`
-      )
-    );
-  }
-
-  return scoring;
-}
+export { aiSignalClarityAction } from './shared/standard-tool-actions';

package/src/commands/deps-health.ts

@@ -1,65 +1 @@
-/**
- * Dependency health command for unified CLI
- */
-
-import chalk from 'chalk';
-import { loadConfig, mergeConfigWithDefaults } from '@aiready/core';
-import type { ToolScoringOutput } from '@aiready/core';
-
-export async function depsHealthAction(
-  directory: string,
-  options: any
-): Promise<ToolScoringOutput | undefined> {
-  const { analyzeDeps } = await import('@aiready/deps');
-
-  const config = await loadConfig(directory);
-  const merged = mergeConfigWithDefaults(config, {
-    trainingCutoffYear: 2023,
-  });
-
-  const report = await analyzeDeps({
-    rootDir: directory,
-    include: options.include,
-    exclude: options.exclude,
-    trainingCutoffYear:
-      options.trainingCutoffYear ?? merged.trainingCutoffYear ?? 2023,
-  });
-
-  const scoring: ToolScoringOutput = {
-    toolName: 'dependency-health',
-    score: report.summary.score,
-    rawMetrics: report.rawData,
-    factors: [],
-    recommendations: report.recommendations.map((action: string) => ({
-      action,
-      estimatedImpact: 5,
-      priority: 'medium',
-    })),
-  };
-
-  if (options.output === 'json') {
-    return 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.`));
-  }
-
-  return scoring;
-}
+export { depsHealthAction } from './shared/standard-tool-actions';

package/src/commands/doc-drift.ts

@@ -1,62 +1 @@
-/**
- * Doc drift risk command for unified CLI
- */
-
-import chalk from 'chalk';
-import { loadConfig, mergeConfigWithDefaults } from '@aiready/core';
-import type { ToolScoringOutput } from '@aiready/core';
-
-export async function docDriftAction(
-  directory: string,
-  options: any
-): Promise<ToolScoringOutput | undefined> {
-  const { analyzeDocDrift } = await import('@aiready/doc-drift');
-
-  const config = await loadConfig(directory);
-  const merged = mergeConfigWithDefaults(config, {
-    staleMonths: 6,
-  });
-
-  const report = await analyzeDocDrift({
-    rootDir: directory,
-    include: options.include,
-    exclude: options.exclude,
-    staleMonths: options.staleMonths ?? merged.staleMonths ?? 6,
-  });
-
-  const scoring: ToolScoringOutput = {
-    toolName: 'doc-drift',
-    score: report.summary.score,
-    rawMetrics: report.rawData,
-    factors: [],
-    recommendations: report.recommendations.map((action: string) => ({
-      action,
-      estimatedImpact: 5,
-      priority: 'medium',
-    })),
-  };
-
-  if (options.output === 'json') {
-    return 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.`));
-  }
-
-  return scoring;
-}
+export { docDriftAction } from './shared/standard-tool-actions';

package/src/commands/init.ts

@@ -6,6 +6,7 @@ import { ToolName } from '@aiready/core';
 export async function initAction(options: {
   force?: boolean;
   format?: 'json' | 'js';
+  full?: boolean;
 }) {
   const fileExt = options.format === 'js' ? 'js' : 'json';
   const fileName = fileExt === 'js' ? 'aiready.config.js' : 'aiready.json';
@@ -18,7 +19,7 @@ export async function initAction(options: {
     process.exit(1);
   }
 
-  const defaultConfig = {
+  const baseConfig = {
     scan: {
       include: [
         'src/**/*.ts',
@@ -49,28 +50,87 @@ export async function initAction(options: {
       [ToolName.PatternDetect]: {
         minSimilarity: 0.8,
         minLines: 5,
+        ...(options.full
+          ? {
+              batchSize: 50,
+              approx: true,
+              minSharedTokens: 10,
+              maxCandidatesPerBlock: 100,
+            }
+          : {}),
       },
       [ToolName.ContextAnalyzer]: {
         maxContextBudget: 128000,
         minCohesion: 0.6,
+        ...(options.full
+          ? {
+              maxDepth: 7,
+              maxFragmentation: 0.4,
+              focus: 'all',
+              includeNodeModules: false,
+            }
+          : {}),
       },
       [ToolName.NamingConsistency]: {
         shortWords: ['id', 'db', 'ui', 'ai'],
+        ...(options.full
+          ? { acceptedAbbreviations: [], disableChecks: [] }
+          : {}),
       },
       [ToolName.AiSignalClarity]: {
         checkMagicLiterals: true,
         checkBooleanTraps: true,
         checkAmbiguousNames: true,
         checkUndocumentedExports: true,
+        ...(options.full
+          ? { checkImplicitSideEffects: false, checkDeepCallbacks: false }
+          : {}),
       },
+      ...(options.full
+        ? {
+            [ToolName.AgentGrounding]: {
+              maxRecommendedDepth: 5,
+              readmeStaleDays: 30,
+            },
+            [ToolName.TestabilityIndex]: {
+              minCoverageRatio: 0.7,
+              testPatterns: ['**/*.test.ts', '**/__tests__/**'],
+            },
+            [ToolName.DocDrift]: {
+              maxCommits: 50,
+              staleMonths: 3,
+            },
+            [ToolName.DependencyHealth]: {
+              trainingCutoffYear: 2023,
+            },
+          }
+        : {}),
     },
     scoring: {
       threshold: 70,
       showBreakdown: true,
+      ...(options.full ? { profile: 'default' } : {}),
     },
+    ...(options.full
+      ? {
+          output: {
+            format: fileExt,
+            file: 'aiready-report.json',
+          },
+          visualizer: {
+            groupingDirs: ['packages', 'src', 'lib'],
+            graph: {
+              maxNodes: 5000,
+              maxEdges: 10000,
+            },
+          },
+        }
+      : {}),
   };
 
-  let content = '';
+  const defaultConfig = baseConfig;
+
+  let content: string;
   if (fileExt === 'js') {
     content = `/** @type {import('@aiready/core').AIReadyConfig} */\nmodule.exports = ${JSON.stringify(
       defaultConfig,

package/src/commands/scan.ts

@@ -151,7 +151,7 @@ export async function scanAction(directory: string, options: ScanOptions) {
     )) as any;
 
     // Apply smart defaults for pattern detection if requested
-    let finalOptions = { ...baseOptions };
+    const finalOptions = { ...baseOptions };
     if (
       baseOptions.tools.includes(ToolName.PatternDetect) ||
       baseOptions.tools.includes('patterns')
@@ -469,20 +469,20 @@ export async function scanAction(directory: string, options: ScanOptions) {
     }
     await warnIfGraphCapExceeded(outputData, resolvedDir);
 
-    // CI/CD Gatekeeper logic
-    const isCI = options.ci || process.env.CI === 'true';
-    if (isCI && scoringResult) {
+    // Score Check & Gatekeeper logic
+    if (scoringResult) {
       const threshold = options.threshold
         ? parseInt(options.threshold)
         : undefined;
       const failOnLevel = options.failOn || 'critical';
+      const isCI = options.ci || process.env.CI === 'true';
 
       let shouldFail = false;
       let failReason = '';
 
-      // Emit annotations for all issues found
+      // Emit annotations only in CI
       const report = mapToUnifiedReport(results, scoringResult);
-      if (report.results && report.results.length > 0) {
+      if (isCI && report.results && report.results.length > 0) {
         console.log(
           chalk.cyan(
             `\n📝 Emitting GitHub Action annotations for ${report.results.length} issues...`
@@ -495,6 +495,9 @@ export async function scanAction(directory: string, options: ScanOptions) {
         shouldFail = true;
         failReason = `Score ${scoringResult.overall} < threshold ${threshold}`;
       }
+
+      // If failOnLevel is set (default 'critical'), check for issues
+      // But only fail if not 'none'
       if (failOnLevel !== 'none') {
         if (failOnLevel === 'critical' && report.summary.criticalIssues > 0) {
           shouldFail = true;
@@ -509,10 +512,10 @@ export async function scanAction(directory: string, options: ScanOptions) {
       }
 
       if (shouldFail) {
-        console.log(chalk.red(`\n🚫 PR BLOCKED: ${failReason}`));
+        console.log(chalk.red(`\n🚫 SCAN FAILED: ${failReason}`));
         process.exit(1);
       } else {
-        console.log(chalk.green('\n✅ PR PASSED'));
+        console.log(chalk.green('\n✅ SCAN PASSED'));
       }
     }
   } catch (error) {

package/src/commands/shared/configured-tool-action.ts

@@ -0,0 +1,35 @@
+import type { ToolScoringOutput } from '@aiready/core';
+import { runConfiguredToolCommand } from '../../utils/helpers';
+
+export interface ConfiguredToolActionConfig<TReport> {
+  defaults: Record<string, unknown>;
+  analyze: (scanOptions: any) => Promise<TReport>;
+  getExtras: (
+    options: any,
+    merged: Record<string, unknown>
+  ) => Record<string, unknown>;
+  score: (report: TReport) => ToolScoringOutput;
+  render: (report: TReport, scoring: ToolScoringOutput) => void;
+}
+
+export async function runConfiguredToolAction<TReport>(
+  directory: string,
+  options: any,
+  config: ConfiguredToolActionConfig<TReport>
+): Promise<ToolScoringOutput | undefined> {
+  const { report, scoring } = await runConfiguredToolCommand({
+    directory,
+    options,
+    defaults: config.defaults,
+    analyze: config.analyze,
+    getExtras: config.getExtras,
+    score: config.score,
+  });
+
+  if (options.output === 'json') {
+    return scoring;
+  }
+
+  config.render(report, scoring);
+  return scoring;
+}