@aiready/cli 0.12.19 → 0.12.23

package/src/__tests__/unified.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { analyzeUnified, scoreUnified, generateUnifiedSummary } from '../index';
+import { ToolRegistry, ToolName } from '@aiready/core';
+
+vi.mock('@aiready/core', async () => {
+  const actual = await vi.importActual('@aiready/core');
+  return {
+    ...actual,
+    initializeParsers: vi.fn().mockResolvedValue(undefined),
+    calculateOverallScore: vi
+      .fn()
+      .mockReturnValue({ overall: 85, breakdown: [] }),
+    calculateTokenBudget: vi.fn().mockReturnValue({}),
+  };
+});
+
+describe('Unified CLI logic', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('analyzeUnified', () => {
+    it('should run multiple tools and aggregate results', async () => {
+      const mockProvider1 = {
+        id: 'tool1',
+        analyze: vi.fn().mockResolvedValue({
+          results: [{ fileName: 'f1.ts', issues: [{}, {}] }],
+          summary: { totalFiles: 1 },
+        }),
+        score: vi.fn(),
+      };
+
+      vi.spyOn(ToolRegistry, 'find').mockImplementation((id) => {
+        if (id === 'tool1') return mockProvider1 as any;
+        return null;
+      });
+
+      const options = {
+        rootDir: '.',
+        tools: ['tool1'],
+      };
+
+      const result = await analyzeUnified(options as any);
+      expect(result.summary.totalIssues).toBe(2);
+      expect(result.summary.toolsRun).toContain('tool1');
+    });
+  });
+
+  describe('scoreUnified', () => {
+    it('should score results from multiple tools', async () => {
+      const mockProvider = {
+        id: 'tool1',
+        score: vi.fn().mockReturnValue({ score: 80 }),
+      };
+      vi.spyOn(ToolRegistry, 'get').mockReturnValue(mockProvider as any);
+
+      const results = {
+        summary: { toolsRun: ['tool1'] },
+        tool1: { results: [] },
+      };
+
+      const score = await scoreUnified(results as any, { rootDir: '.' } as any);
+      expect(score.overall).toBe(85); // From mocked calculateOverallScore
+      expect(mockProvider.score).toHaveBeenCalled();
+    });
+
+    it('should handle empty tools', async () => {
+      const results = { summary: { toolsRun: [] } };
+      const score = await scoreUnified(results as any, { rootDir: '.' } as any);
+      expect(score.overall).toBe(0);
+    });
+  });
+
+  describe('generateUnifiedSummary', () => {
+    it('should generate human-readable summary', () => {
+      const result = {
+        summary: {
+          toolsRun: ['tool1'],
+          totalIssues: 5,
+          executionTime: 1200,
+        },
+        tool1: { results: [{ issues: [{}, {}] }] },
+      };
+
+      vi.spyOn(ToolRegistry, 'getAll').mockReturnValue([
+        { id: 'tool1' },
+      ] as any);
+
+      const summary = generateUnifiedSummary(result as any);
+      expect(summary).toContain('AIReady Analysis Complete');
+      expect(summary).toContain('Total issues found: 5');
+      expect(summary).toContain('1.20s');
+    });
+  });
+});

package/src/cli.ts

@@ -16,8 +16,15 @@ import {
   visualizeHelpText,
   visualiseHelpText,
   changeAmplificationAction,
+  testabilityAction,
   uploadAction,
   uploadHelpText,
+  clawmartMeAction,
+  clawmartListingsAction,
+  clawmartCreateAction,
+  clawmartUploadAction,
+  clawmartDownloadAction,
+  clawmartHelpText,
 } from './commands';
 
 const getDirname = () => {
@@ -279,6 +286,20 @@ program
     await changeAmplificationAction(directory, options);
   });
 
+// Testability command
+program
+  .command('testability')
+  .description('Analyze test coverage and AI readiness')
+  .argument('[directory]', 'Directory to analyze', '.')
+  .option('--min-coverage <ratio>', 'Minimum acceptable coverage ratio', '0.3')
+  .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', 'console')
+  .option('--output-file <path>', 'Output file path (for json)')
+  .action(async (directory, options) => {
+    await testabilityAction(directory, options);
+  });
+
 // Upload command - Upload report JSON to platform
 program
   .command('upload')
@@ -292,4 +313,69 @@ program
     await uploadAction(file, options);
   });
 
+// ClawMart commands
+const clawmart = program
+  .command('clawmart')
+  .description('Manage ClawMart personas and skills')
+  .addHelpText('after', clawmartHelpText);
+
+clawmart
+  .command('me')
+  .description('Show my ClawMart creator profile')
+  .option('--api-key <key>', 'ClawMart API key')
+  .option('--server <url>', 'Custom ClawMart API server')
+  .action(async (options) => {
+    await clawmartMeAction(options);
+  });
+
+clawmart
+  .command('listings')
+  .description('Show my ClawMart listings')
+  .option('-q, --query <string>', 'Search query')
+  .option('-t, --type <type>', 'Filter by type: skill, persona')
+  .option('-l, --limit <number>', 'Limit results', '10')
+  .option('--api-key <key>', 'ClawMart API key')
+  .option('--server <url>', 'Custom ClawMart API server')
+  .action(async (options) => {
+    await clawmartListingsAction(options);
+  });
+
+clawmart
+  .command('create')
+  .description('Create a new listing on ClawMart')
+  .requiredOption('--name <string>', 'Listing name')
+  .requiredOption('--tagline <string>', 'Short tagline')
+  .option('--about <string>', 'Full description')
+  .option('--category <string>', 'Category', 'Utility')
+  .option('--capabilities <string>', 'Comma-separated list of capabilities')
+  .option('--price <number>', 'Price in USD', '0')
+  .option('--type <type>', 'Product type: skill, persona', 'skill')
+  .option('--api-key <key>', 'ClawMart API key')
+  .option('--server <url>', 'Custom ClawMart API server')
+  .action(async (options) => {
+    await clawmartCreateAction(options);
+  });
+
+clawmart
+  .command('upload')
+  .description('Upload content to a listing')
+  .argument('<id>', 'Listing ID')
+  .argument('<files...>', 'Files or directories to upload')
+  .option('--api-key <key>', 'ClawMart API key')
+  .option('--server <url>', 'Custom ClawMart API server')
+  .action(async (id, files, options) => {
+    await clawmartUploadAction(id, files as string[], options);
+  });
+
+clawmart
+  .command('download')
+  .description('Download a package from ClawMart')
+  .argument('<idOrSlug>', 'Listing ID or Slug')
+  .option('--outDir <path>', 'Output directory')
+  .option('--api-key <key>', 'ClawMart API key')
+  .option('--server <url>', 'Custom ClawMart API server')
+  .action(async (idOrSlug, options) => {
+    await clawmartDownloadAction(idOrSlug, options);
+  });
+
 program.parse();

package/src/commands/__tests__/agent-grounding.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect, vi } from 'vitest';
+import { agentGroundingAction } from '../agent-grounding';
+
+vi.mock('@aiready/agent-grounding', () => ({
+  analyzeAgentGrounding: vi.fn().mockResolvedValue({
+    summary: { score: 75, rating: 'good', dimensions: { apiClarityScore: 60 } },
+    results: [],
+  }),
+  calculateGroundingScore: vi.fn().mockReturnValue({ score: 75 }),
+}));
+
+vi.mock('@aiready/core', () => ({
+  loadConfig: vi.fn().mockResolvedValue({}),
+  mergeConfigWithDefaults: vi
+    .fn()
+    .mockImplementation((c, d) => ({ ...d, ...c })),
+}));
+
+describe('Agent Grounding CLI Action', () => {
+  it('should run analysis and return scoring', async () => {
+    const result = await agentGroundingAction('.', { output: 'json' });
+    expect(result?.score).toBe(75);
+  });
+});

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

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi } from 'vitest';
+import { aiSignalClarityAction } from '../ai-signal-clarity';
+
+vi.mock('@aiready/ai-signal-clarity', () => ({
+  analyzeAiSignalClarity: vi.fn().mockResolvedValue({
+    summary: {
+      score: 85,
+      rating: 'low',
+      topRisk: 'none',
+      totalSignals: 0,
+      criticalSignals: 0,
+      majorSignals: 0,
+      minorSignals: 0,
+    },
+    results: [],
+  }),
+  calculateAiSignalClarityScore: vi.fn().mockReturnValue({ score: 85 }),
+}));
+
+vi.mock('@aiready/core', () => ({
+  loadConfig: vi.fn().mockResolvedValue({}),
+  mergeConfigWithDefaults: vi
+    .fn()
+    .mockImplementation((c, d) => ({ ...d, ...c })),
+}));
+
+describe('AI Signal Clarity CLI Action', () => {
+  it('should run analysis and return scoring', async () => {
+    const result = await aiSignalClarityAction('.', { output: 'json' });
+    expect(result?.score).toBe(85);
+  });
+});

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

@@ -0,0 +1,97 @@
+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' },
+    });
+  });
+
+  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' },
+    });
+    await consistencyAction('.', {});
+    expect(core.handleJSONOutput).toHaveBeenCalled();
+  });
+
+  it('supports Markdown output', async () => {
+    vi.mocked(core.loadMergedConfig).mockResolvedValue({
+      output: { format: 'markdown' },
+    });
+    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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,177 @@
+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';
+import * as core from '@aiready/core';
+
+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: '.',
+      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();
+  });
+});