@aiready/cli 0.14.14 → 0.14.16

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

@@ -1,100 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { consistencyAction } from '../consistency';
-import * as core from '@aiready/core';
-import * as fs from 'fs';
-
-vi.mock('@aiready/core', async () => {
-  const actual = await vi.importActual('@aiready/core');
-  return {
-    ...actual,
-    loadMergedConfig: vi.fn(),
-    handleJSONOutput: vi.fn(),
-    handleCLIError: vi.fn(),
-    getElapsedTime: vi.fn().mockReturnValue('1.0'),
-    resolveOutputPath: vi.fn().mockReturnValue('report.json'),
-    formatToolScore: vi.fn().mockReturnValue('Score: 80'),
-  };
-});
-
-vi.mock('fs', async () => {
-  const actual = await vi.importActual('fs');
-  return {
-    ...actual,
-    writeFileSync: vi.fn(),
-  };
-});
-
-vi.mock('@aiready/consistency', () => ({
-  analyzeConsistency: vi.fn().mockResolvedValue({
-    results: [
-      {
-        fileName: 'f1.ts',
-        issues: [
-          {
-            category: 'naming',
-            severity: 'major',
-            message: 'Bad name',
-            location: { file: 'f1.ts', line: 1 },
-          },
-        ],
-      },
-    ],
-    summary: {
-      filesAnalyzed: 1,
-      totalIssues: 1,
-      namingIssues: 1,
-      patternIssues: 0,
-    },
-    recommendations: ['Fix names'],
-  }),
-  calculateConsistencyScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-
-import { analyzeConsistency } from '@aiready/consistency';
-
-describe('Consistency CLI Action', () => {
-  let consoleSpy: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.mocked(core.loadMergedConfig).mockResolvedValue({
-      output: { format: 'console' },
-      rootDir: '/test',
-    });
-  });
-
-  it('runs consistency analysis and outputs to console', async () => {
-    await consistencyAction('.', {});
-    expect(analyzeConsistency).toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Summary'));
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Naming Issues')
-    );
-  });
-
-  it('supports JSON output', async () => {
-    vi.mocked(core.loadMergedConfig).mockResolvedValue({
-      output: { format: 'json' },
-      rootDir: '/test',
-    });
-    await consistencyAction('.', {});
-    expect(core.handleJSONOutput).toHaveBeenCalled();
-  });
-
-  it('supports Markdown output', async () => {
-    vi.mocked(core.loadMergedConfig).mockResolvedValue({
-      output: { format: 'markdown' },
-      rootDir: '/test',
-    });
-    await consistencyAction('.', {});
-    expect(fs.writeFileSync).toHaveBeenCalled();
-  });
-
-  it('calculates score if requested', async () => {
-    await consistencyAction('.', { score: true });
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('AI Readiness Score')
-    );
-  });
-});

package/src/commands/__tests__/deps-health.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { depsHealthAction } from '../deps-health';
-
-vi.mock('@aiready/deps', () => ({
-  analyzeDeps: vi.fn().mockResolvedValue({
-    summary: { score: 90, rating: 'excellent' },
-    rawData: {},
-    recommendations: [],
-    issues: [],
-  }),
-}));
-
-vi.mock('@aiready/core', () => ({
-  loadConfig: vi.fn().mockResolvedValue({}),
-  mergeConfigWithDefaults: vi
-    .fn()
-    .mockImplementation((c, d) => ({ ...d, ...c })),
-}));
-
-describe('Deps Health CLI Action', () => {
-  it('should run analysis and return scoring', async () => {
-    const result = await depsHealthAction('.', { output: 'json' });
-    expect(result?.toolName).toBe('dependency-health');
-    expect(result?.score).toBe(90);
-  });
-});

package/src/commands/__tests__/doc-drift.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { docDriftAction } from '../doc-drift';
-
-vi.mock('@aiready/doc-drift', () => ({
-  analyzeDocDrift: vi.fn().mockResolvedValue({
-    summary: { score: 20, rating: 'low' },
-    rawData: {},
-    recommendations: ['Update docs'],
-    issues: [],
-  }),
-}));
-
-vi.mock('@aiready/core', () => ({
-  loadConfig: vi.fn().mockResolvedValue({}),
-  mergeConfigWithDefaults: vi
-    .fn()
-    .mockImplementation((c, d) => ({ ...d, ...c })),
-}));
-
-describe('Doc Drift CLI Action', () => {
-  it('should run analysis and return scoring', async () => {
-    const result = await docDriftAction('.', { output: 'json' });
-    expect(result?.toolName).toBe('doc-drift');
-    expect(result?.score).toBe(20);
-  });
-});

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

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { changeAmplificationAction } from '../change-amplification';
-import { agentGroundingAction } from '../agent-grounding';
-import { aiSignalClarityAction } from '../ai-signal-clarity';
-import { docDriftAction } from '../doc-drift';
-import { testabilityAction } from '../testability';
-import { depsHealthAction } from '../deps-health';
-import { patternsAction } from '../patterns';
-import { contextAction } from '../context';
-
-vi.mock('@aiready/core', async () => {
-  const actual = await vi.importActual('@aiready/core');
-  return {
-    ...actual,
-    loadConfig: vi.fn().mockResolvedValue({}),
-    mergeConfigWithDefaults: vi
-      .fn()
-      .mockImplementation((c, d) => ({ ...d, ...c })),
-    loadMergedConfig: vi.fn().mockResolvedValue({
-      rootDir: '/test',
-      output: { format: 'console' },
-      checkNaming: true,
-      checkPatterns: true,
-    }),
-    handleJSONOutput: vi.fn(),
-    handleCLIError: vi.fn(),
-    getElapsedTime: vi.fn().mockReturnValue('1.0'),
-    resolveOutputPath: vi.fn().mockReturnValue('report.json'),
-    formatToolScore: vi.fn().mockReturnValue('Score: 80'),
-  };
-});
-
-// Mock all spokes
-vi.mock('@aiready/change-amplification', () => ({
-  analyzeChangeAmplification: vi.fn().mockResolvedValue({
-    results: [],
-    summary: { rating: 'contained' },
-    recommendations: [],
-  }),
-  calculateChangeAmplificationScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-vi.mock('@aiready/agent-grounding', () => ({
-  analyzeAgentGrounding: vi.fn().mockResolvedValue({
-    results: [],
-    summary: {
-      rating: 'grounded',
-      dimensions: { structure: 80, metadata: 80 },
-    },
-    recommendations: [],
-  }),
-  calculateGroundingScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-vi.mock('@aiready/ai-signal-clarity', () => ({
-  analyzeAiSignalClarity: vi.fn().mockResolvedValue({
-    results: [],
-    summary: { rating: 'clear', topRisk: 'none' },
-    recommendations: [],
-  }),
-  calculateAiSignalClarityScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-vi.mock('@aiready/doc-drift', () => ({
-  analyzeDocDrift: vi.fn().mockResolvedValue({
-    results: [],
-    summary: { rating: 'fresh' },
-    issues: [],
-    rawData: {},
-    recommendations: [],
-  }),
-  calculateDocDriftScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-vi.mock('@aiready/testability', () => ({
-  analyzeTestability: vi.fn().mockResolvedValue({
-    results: [],
-    summary: { rating: 'testable', aiChangeSafetyRating: 'safe' },
-    rawData: {},
-    recommendations: [],
-  }),
-  calculateTestabilityScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-vi.mock('@aiready/deps', () => ({
-  analyzeDeps: vi.fn().mockResolvedValue({
-    results: [],
-    summary: { packagesAnalyzed: 0, filesAnalyzed: 0, rating: 'healthy' },
-    issues: [],
-    rawData: {},
-    recommendations: [],
-  }),
-  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: [],
-  }),
-  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,
-  }),
-  getSmartDefaults: vi.fn().mockResolvedValue({}),
-}));
-
-describe('Extra CLI Actions', () => {
-  let consoleSpy: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  it('runs change-amplification', async () => {
-    await changeAmplificationAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs agent-grounding', async () => {
-    await agentGroundingAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs ai-signal-clarity', async () => {
-    await aiSignalClarityAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs doc-drift', async () => {
-    await docDriftAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs testability', async () => {
-    await testabilityAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs deps-health', async () => {
-    await depsHealthAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs patterns', async () => {
-    await patternsAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('runs context', async () => {
-    await contextAction('.', {});
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-});

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

@@ -1,51 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { existsSync, readFileSync, unlinkSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { initAction } from '../init';
-
-describe('initAction', () => {
-  const testDir = join(process.cwd(), 'temp-test-init');
-  const configPath = join(testDir, 'aiready.json');
-
-  beforeEach(() => {
-    if (!existsSync(testDir)) {
-      mkdirSync(testDir, { recursive: true });
-    }
-    // Mock process.cwd to use our test directory
-    vi.spyOn(process, 'cwd').mockReturnValue(testDir);
-    // Mock console.log to avoid noise
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    if (existsSync(configPath)) {
-      unlinkSync(configPath);
-    }
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  it('should generate aiready.json with output field by default', async () => {
-    await initAction({});
-
-    expect(existsSync(configPath)).toBe(true);
-    const config = JSON.parse(readFileSync(configPath, 'utf8'));
-    expect(config).toHaveProperty('output');
-    expect(config.output.format).toBe('console');
-  });
-
-  it('should include scan, tools, scoring, and visualizer sections', async () => {
-    await initAction({ full: true });
-
-    const config = JSON.parse(readFileSync(configPath, 'utf8'));
-    expect(config).toHaveProperty('scan');
-    expect(config).toHaveProperty('tools');
-    expect(config).toHaveProperty('scoring');
-    expect(config).toHaveProperty('output');
-    expect(config).toHaveProperty('visualizer');
-    expect(config).toHaveProperty('threshold');
-  });
-});

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

@@ -1,153 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { scanAction } from '../scan';
-import * as core from '@aiready/core';
-import * as index from '../../index';
-import * as upload from '../upload';
-import { readFileSync } from 'fs';
-import { Severity } from '@aiready/core';
-
-vi.mock('../../index', () => ({
-  analyzeUnified: vi.fn(),
-  scoreUnified: vi.fn(),
-}));
-
-vi.mock('../upload', () => ({
-  uploadAction: vi.fn(),
-}));
-
-vi.mock('@aiready/core', async () => {
-  const actual = await vi.importActual('@aiready/core');
-  return {
-    ...actual,
-    loadMergedConfig: vi.fn(),
-    loadConfig: vi.fn(),
-    getRepoMetadata: vi.fn().mockReturnValue({ name: 'test-repo' }),
-    handleJSONOutput: vi.fn(),
-    handleCLIError: vi.fn(),
-    getElapsedTime: vi.fn().mockReturnValue('1.0'),
-    resolveOutputPath: vi.fn().mockReturnValue('report.json'),
-    formatScore: vi.fn().mockReturnValue('80/100'),
-    calculateTokenBudget: vi.fn().mockReturnValue({
-      efficiencyRatio: 0.8,
-      wastedTokens: {
-        total: 100,
-        bySource: { duplication: 50, fragmentation: 50 },
-      },
-      totalContextTokens: 1000,
-    }),
-    calculateBusinessROI: vi.fn().mockReturnValue({
-      monthlySavings: 500,
-      productivityGainHours: 20,
-      annualValue: 6000,
-    }),
-  };
-});
-
-vi.mock('fs', () => ({
-  writeFileSync: vi.fn(),
-  readFileSync: vi.fn(),
-  existsSync: vi.fn().mockReturnValue(true),
-}));
-
-describe('Scan CLI Action', () => {
-  let consoleSpy: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.mocked(core.loadMergedConfig).mockResolvedValue({
-      tools: ['pattern-detect'],
-      output: { format: 'console' },
-      rootDir: '/test',
-    });
-    vi.mocked(index.analyzeUnified).mockResolvedValue({
-      summary: {
-        totalIssues: 5,
-        toolsRun: ['pattern-detect'],
-        totalFiles: 10,
-        executionTime: 1000,
-      },
-      'pattern-detect': {
-        results: [
-          {
-            fileName: 'f1.ts',
-            issues: [
-              { severity: Severity.Critical },
-              { severity: Severity.Major },
-            ],
-          },
-        ],
-      },
-    } as any);
-    vi.mocked(index.scoreUnified).mockResolvedValue({
-      overall: 80,
-      breakdown: [
-        {
-          toolName: 'pattern-detect',
-          score: 80,
-          tokenBudget: {
-            totalContextTokens: 1000,
-            wastedTokens: { bySource: { duplication: 50, fragmentation: 50 } },
-          },
-        },
-      ],
-    } as any);
-  });
-
-  it('runs standard scan with scoring', async () => {
-    await scanAction('.', { score: true });
-    expect(index.analyzeUnified).toHaveBeenCalled();
-    expect(index.scoreUnified).toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('AI Readiness Overall Score')
-    );
-  });
-
-  it('handles profiles correctly', async () => {
-    await scanAction('.', { profile: 'agentic' });
-    expect(core.loadMergedConfig).toHaveBeenCalled();
-  });
-
-  it('compares with previous report', async () => {
-    vi.mocked(readFileSync).mockReturnValue(
-      JSON.stringify({ scoring: { overall: 70 } })
-    );
-    await scanAction('.', { compareTo: 'prev.json', score: true });
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Trend: +10')
-    );
-  });
-
-  it('handles CI failure on critical issues', async () => {
-    const exitSpy = vi
-      .spyOn(process, 'exit')
-      .mockImplementation((() => {}) as any);
-
-    await scanAction('.', { ci: true, failOn: 'critical', score: true });
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('SCAN FAILED')
-    );
-    // Verify annotations are emitted
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Emitting GitHub Action annotations')
-    );
-    exitSpy.mockRestore();
-  });
-
-  it('handles upload flag', async () => {
-    await scanAction('.', { upload: true, apiKey: 'test-key' });
-    expect(upload.uploadAction).toHaveBeenCalled();
-  });
-
-  it('supports JSON output format', async () => {
-    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__/testability.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { testabilityAction } from '../testability';
-
-vi.mock('@aiready/testability', () => ({
-  analyzeTestability: vi.fn().mockResolvedValue({
-    summary: {
-      score: 80,
-      rating: 'good',
-      aiChangeSafetyRating: 'safe',
-      coverageRatio: 0.5,
-    },
-    rawData: { testFiles: 5, sourceFiles: 10 },
-  }),
-  calculateTestabilityScore: vi.fn().mockReturnValue({ score: 80 }),
-}));
-
-vi.mock('@aiready/core', () => ({
-  loadConfig: vi.fn().mockResolvedValue({}),
-  mergeConfigWithDefaults: vi
-    .fn()
-    .mockImplementation((c, d) => ({ ...d, ...c })),
-}));
-
-describe('Testability CLI Action', () => {
-  it('should run analysis and return scoring in json mode', async () => {
-    const result = await testabilityAction('.', { output: 'json' });
-    expect(result?.score).toBe(80);
-  });
-
-  it('should run analysis and print to console in default mode', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await testabilityAction('.', { output: 'console' });
-    expect(consoleSpy).toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-});

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

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { uploadAction } from '../upload';
-
-vi.mock('fs', () => ({
-  default: {
-    existsSync: vi.fn().mockReturnValue(true),
-    readFileSync: vi.fn().mockReturnValue('{"test": true}'),
-  },
-}));
-
-vi.mock('@aiready/core', () => ({
-  handleCLIError: vi.fn(),
-}));
-
-describe('Upload CLI Action', () => {
-  beforeEach(() => {
-    vi.stubGlobal(
-      'fetch',
-      vi.fn().mockResolvedValue({
-        ok: true,
-        headers: { get: () => 'application/json' },
-        json: () =>
-          Promise.resolve({
-            success: true,
-            analysis: { id: '123', aiScore: 80 },
-          }),
-      })
-    );
-    vi.stubGlobal('process', {
-      ...process,
-      exit: vi.fn(),
-    });
-  });
-
-  it('should upload report successfully', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await uploadAction('report.json', { apiKey: 'test-key' });
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Upload successful')
-    );
-    consoleSpy.mockRestore();
-  });
-
-  it('should fail if API key is missing', async () => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    await uploadAction('report.json', {});
-    expect(process.exit).toHaveBeenCalledWith(1);
-    consoleSpy.mockRestore();
-  });
-});

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

@@ -1,78 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { visualizeAction } from '../visualize';
-import * as fs from 'fs';
-import * as core from '@aiready/core';
-import { spawn } from 'child_process';
-
-vi.mock('fs', async () => {
-  const actual = await vi.importActual('fs');
-  return {
-    ...actual,
-    readFileSync: vi.fn(),
-    existsSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    copyFileSync: vi.fn(),
-  };
-});
-
-vi.mock('child_process', () => ({
-  spawn: vi.fn().mockReturnValue({ on: vi.fn(), kill: vi.fn() }),
-}));
-
-vi.mock('@aiready/visualizer/graph', () => ({
-  GraphBuilder: {
-    buildFromReport: vi.fn().mockReturnValue({ nodes: [], edges: [] }),
-  },
-}));
-
-vi.mock('@aiready/core', () => ({
-  handleCLIError: vi.fn(),
-  generateHTML: vi.fn().mockReturnValue('<html></html>'),
-  findLatestReport: vi.fn(),
-}));
-
-describe('Visualize CLI Action', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(fs, 'existsSync').mockReturnValue(true);
-    vi.spyOn(fs, 'readFileSync').mockReturnValue(
-      JSON.stringify({ scoring: { overall: 80 } })
-    );
-  });
-
-  it('should generate HTML from specified report', async () => {
-    await visualizeAction('.', { report: 'report.json' });
-    expect(fs.writeFileSync).toHaveBeenCalledWith(
-      expect.stringContaining('visualization.html'),
-      '<html></html>',
-      'utf8'
-    );
-  });
-
-  it('should find latest report if none specified', async () => {
-    vi.mocked(core.findLatestReport).mockReturnValue('latest.json');
-    await visualizeAction('.', {});
-    expect(fs.readFileSync).toHaveBeenCalledWith(
-      expect.stringContaining('latest.json'),
-      'utf8'
-    );
-  });
-
-  it('should handle missing reports', async () => {
-    vi.spyOn(fs, 'existsSync').mockReturnValue(false);
-    vi.mocked(core.findLatestReport).mockReturnValue(null);
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    await visualizeAction('.', { report: 'missing.json' });
-
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('No AI readiness report found')
-    );
-    consoleSpy.mockRestore();
-  });
-
-  it('should attempt to open visualization if requested', async () => {
-    await visualizeAction('.', { report: 'report.json', open: true });
-    expect(spawn).toHaveBeenCalled();
-  });
-});