@aiready/cli 0.12.20 → 0.12.23

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

@@ -0,0 +1,147 @@
+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 { writeFileSync, readFileSync, existsSync } 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' },
+    });
+    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('PR BLOCKED')
+    );
+    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' },
+    });
+    await scanAction('.', {});
+    expect(core.handleJSONOutput).toHaveBeenCalled();
+  });
+});

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

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

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { uploadAction } from '../upload';
+import fs from 'fs';
+
+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

@@ -0,0 +1,82 @@
+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 () => {
+  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>'),
+}));
+
+vi.mock('../../utils/helpers', () => ({
+  findLatestScanReport: 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.spyOn(helpers, 'findLatestScanReport').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.spyOn(helpers, 'findLatestScanReport').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();
+  });
+});

package/src/commands/clawmart.ts

@@ -0,0 +1,162 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { resolve as resolvePath } from 'path';
+import {
+  ClawMartClient,
+  ClawMartListing,
+  DownloadPackageResponse,
+} from '@aiready/clawmart';
+
+function getClient(options: any) {
+  const apiKey = options.apiKey || process.env.CLAWMART_API_KEY;
+  if (!apiKey) {
+    console.error(chalk.red('❌ ClawMart API Key is required.'));
+    console.log(
+      chalk.dim(
+        '   Set CLAWMART_API_KEY environment variable or use --api-key flag.'
+      )
+    );
+    process.exit(1);
+  }
+  return new ClawMartClient(apiKey, options.server);
+}
+
+export async function clawmartMeAction(options: any) {
+  const client = getClient(options);
+  try {
+    const me = await client.getMe();
+    console.log(chalk.blue('\n👤 ClawMart Profile:'));
+    console.log(`   Name:  ${chalk.bold(me.name)}`);
+    console.log(`   Email: ${me.email}`);
+    console.log(`   Role:  ${me.isCreator ? 'Creator' : 'User'}`);
+    console.log(
+      `   Sub:   ${me.subscriptionActive ? chalk.green('Active') : chalk.red('Inactive')}`
+    );
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to fetch profile: ${error.message}`));
+  }
+}
+
+export async function clawmartListingsAction(options: any) {
+  const client = getClient(options);
+  try {
+    let listings;
+    if (options.query) {
+      listings = await client.searchListings(
+        options.query,
+        options.type,
+        options.limit
+      );
+    } else {
+      listings = await client.getListings();
+    }
+
+    if (listings.length === 0) {
+      console.log(chalk.yellow('\n📭 No listings found.'));
+      return;
+    }
+
+    console.log(chalk.blue(`\n🏠 ClawMart Listings (${listings.length}):`));
+    listings.forEach((l: ClawMartListing) => {
+      const status = l.published
+        ? chalk.green('Published')
+        : chalk.yellow('Draft');
+      console.log(`   - ${chalk.bold(l.name)} (${chalk.dim(l.id)})`);
+      console.log(`     ${chalk.italic(l.tagline)}`);
+      console.log(
+        `     Price: $${l.price} | Type: ${l.productType} | Status: ${status}`
+      );
+      console.log('');
+    });
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to fetch listings: ${error.message}`));
+  }
+}
+
+export async function clawmartCreateAction(options: any) {
+  const client = getClient(options);
+  try {
+    const data = {
+      name: options.name,
+      tagline: options.tagline,
+      about: options.about || '',
+      category: options.category || 'Utility',
+      capabilities: options.capabilities ? options.capabilities.split(',') : [],
+      price: parseFloat(options.price) || 0,
+      productType: options.type as 'skill' | 'persona',
+    };
+
+    const listing = await client.createListing(data);
+    console.log(chalk.green(`\n✅ Listing created successfully!`));
+    console.log(`   ID:   ${listing.id}`);
+    console.log(`   Name: ${listing.name}`);
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to create listing: ${error.message}`));
+  }
+}
+
+export async function clawmartUploadAction(
+  id: string,
+  files: string[],
+  options: any
+) {
+  const client = getClient(options);
+  try {
+    const fileData = files.map((f) => {
+      const path = resolvePath(process.cwd(), f);
+      if (!fs.existsSync(path)) {
+        throw new Error(`File not found: ${f}`);
+      }
+      return {
+        path: f,
+        content: fs.readFileSync(path, 'utf-8'),
+      };
+    });
+
+    await client.uploadVersion(id, fileData);
+    console.log(
+      chalk.green(`\n✅ New version uploaded successfully to listing ${id}!`)
+    );
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to upload version: ${error.message}`));
+  }
+}
+
+export async function clawmartDownloadAction(idOrSlug: string, options: any) {
+  const client = getClient(options);
+  try {
+    const pkg = await client.downloadPackage(idOrSlug);
+    const outDir = options.outDir || `./clawmart-${pkg.slug}`;
+
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
+    }
+
+    pkg.files.forEach((f: DownloadPackageResponse['files'][number]) => {
+      const filePath = resolvePath(outDir, f.path);
+      const dir = resolvePath(filePath, '..');
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(filePath, f.content);
+    });
+
+    console.log(
+      chalk.green(`\n✅ Package ${idOrSlug} downloaded to ${outDir}`)
+    );
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to download package: ${error.message}`));
+  }
+}
+
+export const clawmartHelpText = `
+EXAMPLES:
+  $ aiready clawmart me
+  $ aiready clawmart listings --query "marketing"
+  $ aiready clawmart create --name "SEO Booster" --tagline "Boost your SEO" --type skill --price 10
+  $ aiready clawmart upload <listing-id> SKILL.md rules/
+  $ aiready clawmart download <listing-id-or-slug> --outDir ./my-skill
+
+ENVIRONMENT VARIABLES:
+  CLAWMART_API_KEY    Your ClawMart creator API key
+`;

package/src/commands/index.ts

@@ -16,3 +16,11 @@ export { agentGroundingAction } from './agent-grounding';
 export { testabilityAction } from './testability';
 export { changeAmplificationAction } from './change-amplification';
 export { uploadAction, uploadHelpText } from './upload';
+export {
+  clawmartMeAction,
+  clawmartListingsAction,
+  clawmartCreateAction,
+  clawmartUploadAction,
+  clawmartDownloadAction,
+  clawmartHelpText,
+} from './clawmart';

package/src/commands/scan.ts

@@ -262,28 +262,50 @@ export async function scanAction(directory: string, options: ScanOptions) {
           wastedTokens: {
             duplication: totalWastedDuplication,
             fragmentation: totalWastedFragmentation,
-            chattiness: 0,
+            chattiness: totalContext * 0.1, // Default chattiness
           },
         });
-        const modelPreset = getModelPreset(options.model || 'claude-4.6');
-        const costEstimate = estimateCostFromBudget(unifiedBudget, modelPreset);
 
-        console.log(chalk.bold('\n📊 AI Token Budget Analysis'));
+        const allIssues: any[] = [];
+        for (const toolId of results.summary.toolsRun) {
+          if (results[toolId]?.results) {
+            results[toolId].results.forEach((fileRes: any) => {
+              if (fileRes.issues) {
+                allIssues.push(...fileRes.issues);
+              }
+            });
+          }
+        }
+
+        const modelId = options.model || 'claude-3-5-sonnet';
+        const roi = (await import('@aiready/core')).calculateBusinessROI({
+          tokenWaste: unifiedBudget.wastedTokens.total,
+          issues: allIssues,
+          modelId: modelId,
+        });
+
+        console.log(chalk.bold('\n💰 Business Impact Analysis (Monthly)'));
         console.log(
-          `  Efficiency: ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
+          `  Potential Savings: ${chalk.green(chalk.bold('$' + roi.monthlySavings.toLocaleString()))}`
         );
         console.log(
-          `  Wasted Tokens: ${chalk.red(unifiedBudget.wastedTokens.total.toLocaleString())}`
+          `  Productivity Gain: ${chalk.cyan(chalk.bold(roi.productivityGainHours + 'h'))} (est. dev time)`
         );
         console.log(
-          `  Est. Monthly Cost (${modelPreset.name}): ${chalk.bold('$' + costEstimate.total)}`
+          `  Context Efficiency: ${chalk.yellow((unifiedBudget.efficiencyRatio * 100).toFixed(0) + '%')}`
+        );
+        console.log(
+          `  Annual Value: ${chalk.bold('$' + roi.annualValue.toLocaleString())} (ROI Prediction)`
         );
 
-        (scoringResult as any).tokenBudget = unifiedBudget;
-        (scoringResult as any).costEstimate = {
-          model: modelPreset.name,
-          ...costEstimate,
+        (results.summary as any).businessImpact = {
+          estimatedMonthlyWaste: roi.monthlySavings,
+          potentialSavings: roi.monthlySavings,
+          productivityHours: roi.productivityGainHours,
         };
+
+        (scoringResult as any).tokenBudget = unifiedBudget;
+        (scoringResult as any).businessROI = roi;
       }
 
       if (scoringResult.breakdown) {

package/src/utils/__tests__/helpers.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getReportTimestamp,
+  truncateArray,
+  generateMarkdownReport,
+} from '../helpers';
+
+describe('CLI Helpers', () => {
+  it('should generate a valid timestamp', () => {
+    const ts = getReportTimestamp();
+    expect(ts).toMatch(/^\d{8}-\d{6}$/);
+  });
+
+  it('should truncate arrays correctly', () => {
+    const arr = [1, 2, 3, 4, 5];
+    expect(truncateArray(arr, 3)).toContain('+2 more');
+    expect(truncateArray(arr, 10)).toBe('1, 2, 3, 4, 5');
+  });
+
+  it('should generate markdown report', () => {
+    const report = {
+      summary: {
+        filesAnalyzed: 10,
+        totalIssues: 5,
+        namingIssues: 2,
+        patternIssues: 3,
+      },
+      recommendations: ['Fix naming'],
+    };
+    const md = generateMarkdownReport(report, '1.5');
+    expect(md).toContain('# Consistency Analysis Report');
+    expect(md).toContain('**Files Analyzed:** 10');
+    expect(md).toContain('Fix naming');
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+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'
+      ),
+    },
+  },
+});