@aiready/cli 0.9.38 → 0.9.40

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.9.38 build /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.9.40 build /Users/pengcao/projects/aiready/packages/cli
 > tsup src/index.ts src/cli.ts --format cjs,esm
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -10,20 +10,20 @@
 CJS Build start
 ESM Build start
 
-[10:33:35 PM]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
+[2:35:42 PM]  WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
 
-    src/cli.ts:22:31:
-      22 │   return dirname(fileURLToPath(import.meta.url));
+    src/cli.ts:23:31:
+      23 │   return dirname(fileURLToPath(import.meta.url));
          ╵                                ~~~~~~~~~~~
 
   You need to set the output format to "esm" for "import.meta" to work correctly.
 
 
 
-CJS dist/cli.js   72.49 KB
-CJS dist/index.js 8.47 KB
-CJS ⚡️ Build success in 31ms
+ESM dist/cli.mjs            65.28 KB
 ESM dist/index.mjs          138.00 B
-ESM dist/cli.mjs            62.83 KB
-ESM dist/chunk-JQG7ZATX.mjs 7.12 KB
-ESM ⚡️ Build success in 31ms
+ESM dist/chunk-PDOONNSK.mjs 7.80 KB
+ESM ⚡️ Build success in 491ms
+CJS dist/index.js 9.15 KB
+CJS dist/cli.js   75.53 KB
+CJS ⚡️ Build success in 492ms

package/.turbo/turbo-test.log

@@ -1,17 +1,17 @@
 
 
-> @aiready/cli@0.9.38 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.9.40 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/cli
 
- ✓ src/__tests__/cli.test.ts (3 tests) 6ms
- ✓ dist/__tests__/cli.test.js (3 tests) 3ms
+ ✓ src/__tests__/cli.test.ts (3 tests) 5ms
+ ✓ dist/__tests__/cli.test.js (3 tests) 2ms
 
  Test Files  2 passed (2)
       Tests  6 passed (6)
-   Start at  22:34:03
-   Duration  1.10s (transform 479ms, setup 0ms, import 1.68s, tests 8ms, environment 0ms)
+   Start at  14:39:26
+   Duration  11.33s (transform 3.58s, setup 0ms, import 16.97s, tests 6ms, environment 0ms)
 
 [?25h

package/README.md

@@ -1,8 +1,6 @@
 # @aiready/cli
 
-> **Unified CLI for AIReady analysis tools - Run all AI-readiness checks from a single command**
-
-The CLI provides both unified analysis (scan multiple tools at once) and individual tool access for pattern detection, context analysis, and consistency checking.
+> Unified command-line interface for the AIReady framework.
 
 ## 🏛️ Architecture
 
@@ -10,296 +8,38 @@ The CLI provides both unified analysis (scan multiple tools at once) and individ
                     🎯 USER
                       │
                       ▼
-┌──────────────────────────────────────────┐
-│      🎛️  CLI (@aiready/cli)              │
-│   Unified Interface & Orchestration      │
-│                YOU ARE HERE              │
-└─────────────────┬────────────────────────┘
-                  │
-    ┌─────────────┴─────────────┐
-    │                           │
-    ▼                           ▼
-┌────────┐                ┌────────┐
-│🎨 VIS- │                │ ANALY- │
-│UALIZER │                │  SIS   │
-│        │                │ SPOKES │
-│✅ Ready│                │        │
-└────────┘                └───┬────┘
-    │                         │
-    │         ┌───────────────┼───────────────┐
-    │         ▼               ▼               ▼
-    │   ┌────────┐      ┌────────┐      ┌────────┐
-    │   │📊 PAT- │      │📦 CON- │      │🔧 CON- │
-    │   │TERN    │      │TEXT    │      │SISTENCY│
-    │   │DETECT  │      │ANALYZER│      │        │
-    │   │✅ Ready│      │✅ Ready│      │✅ Ready│
-    │   └────────┘      └────────┘      └────────┘
-    │         │               │               │
-    └─────────┴───────────────┴───────────────┘
-                              │
-                              ▼
-                    🏢 HUB (@aiready/core)
-```
-
-## 🌍 Language Support
-
-**Currently Supported (64% market coverage):**
-
-- ✅ **TypeScript** (`.ts`, `.tsx`)
-- ✅ **JavaScript** (`.js`, `.jsx`)
-- ✅ **Python** (`.py`) - PEP 8 conventions, import analysis, pattern detection
-
-**Roadmap:**
-
-- 🔜 **Java** (Q3 2026) - Maven/Gradle, Spring Framework
-- 🔜 **Go** (Q4 2026) - Go modules, concurrency patterns
-- 🔜 **Rust** (Q4 2026) - Cargo, ownership patterns
-- 🔜 **C#** (Q1 2027) - .NET, LINQ patterns
-
-Mixed-language projects are fully supported - the tool automatically detects and analyzes each file type appropriately.
-
-## 🚀 Quick Start
-
-**Zero config, works out of the box:**
-
-```bash
-# Run without installation (recommended)
-npx @aiready/cli scan ./src
-
-# Or install globally for simpler command and faster runs
-npm install -g @aiready/cli
-aiready scan ./src
-```
-
-### 🎯 Input & Output
-
-**Input:** Path to your source code directory
-
-```bash
-aiready scan ./src
-```
-
-**Output:** Terminal report + optional JSON file (saved to `.aiready/` directory)
-
-```
-📊 AIReady Scan Results
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔍 Pattern Detection
-   📁 Files analyzed: 47
-   ⚠️  Duplicate patterns: 12 files with 23 issues
-   💰 Wasted tokens: 8,450
-
-📦 Context Analysis
-   📁 Files analyzed: 47
-   ⚠️  High context cost: 8 files
-   🔗 Deep import chains: 5 files
-```
-
-### ✨ Smart Defaults (Zero Config)
-
-- ✅ **Auto-excludes** test files (`**/*.test.*`, `**/*.spec.*`, `**/__tests__/**`)
-- ✅ **Auto-excludes** build outputs (`dist/`, `build/`, `.next/`, `cdk.out/`)
-- ✅ **Auto-excludes** dependencies (`node_modules/`)
-- ✅ **Adaptive thresholds**: Adjusts issue detection based on codebase size
-- ✅ **Unified reporting**: Combines results from all tools into one view
-
-> Override defaults with `--include` or `--exclude` options as needed
-
-## 📦 Commands
-
-### Unified Scan
-
-Run multiple analysis tools in one command:
-
-```bash
-aiready scan <directory>
-```
-
-**Options:**
-
-- `-t, --tools <tools>`: Tools to run (comma-separated: patterns,context,consistency) (default: patterns,context)
-- `--include <patterns>`: File patterns to include (comma-separated)
-- `--exclude <patterns>`: File patterns to exclude (comma-separated)
-- `-o, --output <format>`: Output format: console, json (default: console)
-- `--output-file <path>`: Output file path (defaults to `.aiready/aiready-scan-YYYY-MM-DD.json`)
-
-### Individual Tools
-
-Access each tool directly for focused analysis:
-
-#### Pattern Detection
-
-```bash
-aiready patterns <directory> [options]
-```
-
-**Options:**
-
-- `-s, --similarity <number>`: Minimum similarity score (0-1) (default: 0.40)
-- `-l, --min-lines <number>`: Minimum lines to consider (default: 5)
-- `--include <patterns>`: File patterns to include (comma-separated)
-- `--exclude <patterns>`: File patterns to exclude (comma-separated)
-- `-o, --output <format>`: Output format: console, json (default: console)
-- `--output-file <path>`: Output file path (defaults to `.aiready/pattern-report-YYYY-MM-DD.json`)
-
-#### Context Analysis
-
-```bash
-aiready context <directory> [options]
-```
+         🎛️  @aiready/cli (orchestrator)  ← YOU ARE HERE
+          │     │     │     │     │     │     │     │     │
+          ▼     ▼     ▼     ▼     ▼     ▼     ▼     ▼     ▼
+        [PAT] [CTX] [CON] [AMP] [DEP] [DOC] [SIG] [AGT] [TST]
+          │     │     │     │     │     │     │     │     │
+          └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
+                               │
+                               ▼
+                      🏢 @aiready/core
+
+Legend:
+  PAT = pattern-detect        CTX = context-analyzer
+  CON = consistency           AMP = change-amplification
+  DEP = deps-health           DOC = doc-drift
+  SIG = ai-signal-clarity     AGT = agent-grounding
+  TST = testability
+```
+
+## Overview
 
-**Options:**
-
-- `--max-depth <number>`: Maximum acceptable import depth (default: 5)
-- `--max-context <number>`: Maximum acceptable context budget (tokens) (default: 10000)
-- `--include <patterns>`: File patterns to include (comma-separated)
-- `--exclude <patterns>`: File patterns to exclude (comma-separated)
-- `-o, --output <format>`: Output format: console, json (default: console)
-- `--output-file <path>`: Output file path (defaults to `.aiready/context-report-YYYY-MM-DD.json`)
-
-#### Consistency Analysis
-
-```bash
-aiready consistency <directory> [options]
-```
-
-**Options:**
-
-- `--include <patterns>`: File patterns to include (comma-separated)
-- `--exclude <patterns>`: File patterns to exclude (comma-separated)
-- `-o, --output <format>`: Output format: console, json (default: console)
-- `--output-file <path>`: Output file path (defaults to `.aiready/consistency-report-YYYY-MM-DD.json`)
-
-> **📁 Output Files:** By default, all output files are saved to the `.aiready/` directory in your project root with timestamped filenames. You can override this with `--output-file`.
-
-## 💡 Examples
+The CLI provides both unified analysis (scan multiple tools at once) and individual tool access for pattern detection, context analysis, and consistency checking.
 
-### Basic Usage
+## Usage
 
 ```bash
-# Analyze current directory with all tools
+# Scan a codebase
 aiready scan .
 
-# Run specific tools only
-aiready scan . --tools patterns,context
-
-# Analyze only patterns
-aiready patterns .
-
-# Analyze only context costs
-aiready context .
-
-# Analyze only consistency
-aiready consistency .
-```
-
-### Advanced Usage
-
-```bash
-# Analyze specific file types
-aiready scan ./src --include "**/*.ts,**/*.js"
-
-# Exclude test files
-aiready scan . --exclude "**/*.test.*,**/*.spec.*"
-
-# Save results to JSON file (.aiready/ directory by default)
-aiready scan . --output json
-
-# Save to custom location
-aiready scan . --output json --output-file custom-results.json
-
-# Run only pattern analysis with custom similarity threshold
-aiready patterns . --similarity 0.6 --min-lines 10
-
-# Run context analysis with custom thresholds
-aiready context . --max-depth 3 --max-context 5000
+# Run a specific tool
+aiready pattern-detect .
 ```
 
-## ⚙️ Configuration
-
-AIReady supports configuration files to persist your settings. Create one of these files in your project root:
-
-- `aiready.json`
-- `aiready.config.json`
-- `.aiready.json`
-- `.aireadyrc.json`
-- `aiready.config.js`
-- `.aireadyrc.js`
-
-### Example Configuration
-
-```json
-{
-  "scan": {
-    "include": ["**/*.{ts,tsx,js,jsx}"],
-    "exclude": ["**/test/**", "**/*.test.*", "**/*.spec.*"]
-  },
-  "tools": {
-    "pattern-detect": {
-      "minSimilarity": 0.5,
-      "minLines": 8,
-      "approx": false
-    },
-    "context-analyzer": {
-      "maxDepth": 4,
-      "maxContextBudget": 8000,
-      "includeNodeModules": false
-    }
-  },
-  "output": {
-    "format": "console",
-    "file": "aiready-report.json"
-  }
-}
-```
-
-Configuration values are merged with defaults, and CLI options take precedence over config file settings.
-
-## 🔄 CI/CD Integration
-
-```bash
-# JSON output for automated processing
-aiready scan . --output json --output-file aiready-results.json
-
-# Exit with error code if issues found
-aiready scan . && echo "No issues found" || echo "Issues detected"
-```
-
-## 📊 Output Formats
-
-### Console Output
-
-Human-readable summary with key metrics and issue counts.
-
-### JSON Output
-
-Structured data including:
-
-- Full analysis results
-- Detailed metrics
-- Issue breakdowns
-- Execution timing
-
-## 🚦 Exit Codes
-
-- `0`: Success, no critical issues
-- `1`: Analysis failed or critical issues found
-
-## 🔗 Integration
-
-The CLI is designed to integrate with:
-
-- CI/CD pipelines
-- Pre-commit hooks
-- IDE extensions
-- Automated workflows
-
-For programmatic usage, see the individual packages:
-
-- [@aiready/pattern-detect](https://www.npmjs.com/package/@aiready/pattern-detect)
-- [@aiready/context-analyzer](https://www.npmjs.com/package/@aiready/context-analyzer)
-- [@aiready/consistency](https://www.npmjs.com/package/@aiready/consistency)
-
-## 🌐 Visit Our Website
+## License
 
-**Try AIReady tools online and learn more:** [getaiready.dev](https://getaiready.dev)
+MIT

package/dist/chunk-M7O2MEM5.mjs

@@ -0,0 +1,211 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+import { analyzeConsistency } from "@aiready/consistency";
+var severityOrder = {
+  critical: 4,
+  major: 3,
+  minor: 2,
+  info: 1
+};
+function sortBySeverity(results) {
+  return results.map((file) => {
+    const sortedIssues = [...file.issues].sort((a, b) => {
+      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+      if (severityDiff !== 0) return severityDiff;
+      return (a.location?.line || 0) - (b.location?.line || 0);
+    });
+    return { ...file, issues: sortedIssues };
+  }).sort((a, b) => {
+    const aMaxSeverity = Math.max(...a.issues.map((i) => severityOrder[i.severity] || 0), 0);
+    const bMaxSeverity = Math.max(...b.issues.map((i) => severityOrder[i.severity] || 0), 0);
+    if (aMaxSeverity !== bMaxSeverity) {
+      return bMaxSeverity - aMaxSeverity;
+    }
+    if (a.issues.length !== b.issues.length) {
+      return b.issues.length - a.issues.length;
+    }
+    return a.fileName.localeCompare(b.fileName);
+  });
+}
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context", "consistency"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    const patternResult = await analyzePatterns(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "patterns", data: patternResult });
+    }
+    result.patterns = sortBySeverity(patternResult.results);
+    result.duplicates = patternResult.duplicates;
+    result.summary.totalIssues += patternResult.results.reduce(
+      (sum, file) => sum + file.issues.length,
+      0
+    );
+  }
+  if (tools.includes("context")) {
+    const contextResults = await analyzeContext(options);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "context", data: contextResults });
+    }
+    result.context = contextResults.sort((a, b) => {
+      const severityDiff = (severityOrder[b.severity] || 0) - (severityOrder[a.severity] || 0);
+      if (severityDiff !== 0) return severityDiff;
+      if (a.tokenCost !== b.tokenCost) return b.tokenCost - a.tokenCost;
+      return b.fragmentationScore - a.fragmentationScore;
+    });
+    result.summary.totalIssues += result.context?.length || 0;
+  }
+  if (tools.includes("consistency")) {
+    const consistencyOptions = {
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude,
+      ...options.consistency || {}
+    };
+    const report = await analyzeConsistency(consistencyOptions);
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "consistency", data: report });
+    }
+    if (report.results) {
+      report.results = sortBySeverity(report.results);
+    }
+    result.consistency = report;
+    result.summary.totalIssues += report.summary.totalIssues;
+  }
+  if (tools.includes("doc-drift")) {
+    const { analyzeDocDrift } = await import("@aiready/doc-drift");
+    const report = await analyzeDocDrift({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "doc-drift", data: report });
+    }
+    result.docDrift = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("deps-health")) {
+    const { analyzeDeps } = await import("@aiready/deps");
+    const report = await analyzeDeps({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "deps-health", data: report });
+    }
+    result.deps = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("aiSignalClarity")) {
+    const { analyzeAiSignalClarity } = await import("@aiready/ai-signal-clarity");
+    const report = await analyzeAiSignalClarity({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "aiSignalClarity", data: report });
+    }
+    result.aiSignalClarity = report;
+    result.summary.totalIssues += report.results?.reduce((sum, r) => sum + (r.issues?.length || 0), 0) || 0;
+  }
+  if (tools.includes("grounding")) {
+    const { analyzeAgentGrounding } = await import("@aiready/agent-grounding");
+    const report = await analyzeAgentGrounding({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "grounding", data: report });
+    }
+    result.grounding = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  if (tools.includes("testability")) {
+    const { analyzeTestability } = await import("@aiready/testability");
+    const report = await analyzeTestability({
+      rootDir: options.rootDir,
+      include: options.include,
+      exclude: options.exclude
+    });
+    if (options.progressCallback) {
+      options.progressCallback({ tool: "testability", data: report });
+    }
+    result.testability = report;
+    result.summary.totalIssues += report.issues?.length || 0;
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+function generateUnifiedSummary(result) {
+  const { summary } = result;
+  let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+  output += `\u{1F4CA} Summary:
+`;
+  output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+  output += `   Total issues found: ${summary.totalIssues}
+`;
+  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+  if (result.patterns) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  if (result.consistency) {
+    output += `\u{1F3F7}\uFE0F Consistency Analysis: ${result.consistency.summary.totalIssues} issues
+`;
+  }
+  if (result.docDrift) {
+    output += `\u{1F4DD} Doc Drift Analysis: ${result.docDrift.issues?.length || 0} issues
+`;
+  }
+  if (result.deps) {
+    output += `\u{1F4E6} Dependency Health: ${result.deps.issues?.length || 0} issues
+`;
+  }
+  if (result.aiSignalClarity) {
+    output += `\u{1F9E0} AI Signal Clarity: ${result.aiSignalClarity.summary?.totalSignals || 0} signals
+`;
+  }
+  if (result.grounding) {
+    output += `\u{1F9ED} Agent Grounding: ${result.grounding.issues?.length || 0} issues
+`;
+  }
+  if (result.testability) {
+    output += `\u{1F9EA} Testability Index: ${result.testability.issues?.length || 0} issues
+`;
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  generateUnifiedSummary
+};