@aiready/cli 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,24 @@
+
+
+> @aiready/cli@0.1.0 build /Users/pengcao/projects/aiready/packages/cli
+> tsup src/index.ts src/cli.ts --format cjs,esm --dts
+
+CLI Building entry: src/cli.ts, src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2020
+CJS Build start
+ESM Build start
+CJS dist/cli.js   8.70 KB
+CJS dist/index.js 2.51 KB
+CJS ⚡️ Build success in 54ms
+ESM dist/chunk-S6JWNLN7.mjs 1.40 KB
+ESM dist/index.mjs          138.00 B
+ESM dist/cli.mjs            5.95 KB
+ESM ⚡️ Build success in 55ms
+DTS Build start
+DTS ⚡️ Build success in 560ms
+DTS dist/cli.d.ts    20.00 B
+DTS dist/index.d.ts  731.00 B
+DTS dist/cli.d.mts   20.00 B
+DTS dist/index.d.mts 731.00 B

package/.turbo/turbo-test.log

@@ -0,0 +1,9 @@
+
+
+> @aiready/cli@0.1.0 test /Users/pengcao/projects/aiready/packages/cli
+> vitest run
+
+[?25l
+ RUN  v4.0.16 /Users/pengcao/projects/aiready/packages/cli
+
+ ELIFECYCLE  Test failed. See above for more details.

package/README.md

@@ -0,0 +1,138 @@
+# @aiready/cli
+
+Unified CLI for AIReady analysis tools. Provides both unified analysis and individual tool access.
+
+## Installation
+
+```bash
+npm install -g @aiready/cli
+# or
+pnpm add -g @aiready/cli
+# or
+yarn global add @aiready/cli
+```
+
+## Usage
+
+### Unified Analysis
+
+Run both pattern detection and context analysis:
+
+```bash
+aiready scan <directory>
+```
+
+### Individual Tools
+
+#### 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 (for json)
+
+#### Context Analysis
+
+```bash
+aiready context <directory> [options]
+```
+
+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 (for json)
+
+### Unified Scan Options
+
+```bash
+aiready scan <directory> [options]
+```
+
+Options:
+- `-t, --tools <tools>`: Tools to run (comma-separated: patterns,context) (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 (for json)
+
+## Examples
+
+### Quick Analysis
+
+```bash
+# Analyze current directory with both tools
+aiready scan .
+
+# Analyze only patterns
+aiready patterns .
+
+# Analyze only context costs
+aiready context .
+```
+
+### 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 scan . --output json --output-file results.json
+
+# Run only pattern analysis with custom similarity threshold
+aiready patterns . --similarity 0.6 --min-lines 10
+```
+
+### 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](../pattern-detect)
+- [@aiready/context-analyzer](../context-analyzer)

package/dist/chunk-CHRHSNKI.mjs

@@ -0,0 +1,53 @@
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    result.patterns = await analyzePatterns(options);
+    result.summary.totalIssues += result.patterns.length;
+  }
+  if (tools.includes("context")) {
+    result.context = await analyzeContext(options);
+    result.summary.totalIssues += result.context.length;
+  }
+  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?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-S6JWNLN7.mjs

@@ -0,0 +1,53 @@
+// src/index.ts
+import { analyzePatterns } from "@aiready/pattern-detect";
+import { analyzeContext } from "@aiready/context-analyzer";
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    result.patterns = await analyzePatterns(options);
+    result.summary.totalIssues += result.patterns.length;
+  }
+  if (tools.includes("context")) {
+    result.context = await analyzeContext(options);
+    result.summary.totalIssues += result.context?.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?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  return output;
+}
+
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/index.ts
+var import_pattern_detect = require("@aiready/pattern-detect");
+var import_context_analyzer = require("@aiready/context-analyzer");
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    result.patterns = await (0, import_pattern_detect.analyzePatterns)(options);
+    result.summary.totalIssues += result.patterns.length;
+  }
+  if (tools.includes("context")) {
+    result.context = await (0, import_context_analyzer.analyzeContext)(options);
+    result.summary.totalIssues += result.context?.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?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  return output;
+}
+
+// src/cli.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs = require("fs");
+var program = new import_commander.Command();
+program.name("aiready").description("AIReady - Unified AI-readiness analysis tools").version("0.1.0");
+program.command("scan").description("Run unified analysis on a codebase").argument("<directory>", "Directory to analyze").option("-t, --tools <tools>", "Tools to run (comma-separated: patterns,context)", "patterns,context").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) => {
+  console.log(import_chalk.default.blue("\u{1F680} Starting AIReady unified analysis...\n"));
+  const startTime = Date.now();
+  try {
+    const tools = options.tools.split(",").map((t) => t.trim());
+    const results = await analyzeUnified({
+      rootDir: directory,
+      tools,
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    if (options.output === "json") {
+      const outputData = {
+        ...results,
+        summary: {
+          ...results.summary,
+          executionTime: parseFloat(elapsedTime)
+        }
+      };
+      if (options.outputFile) {
+        (0, import_fs.writeFileSync)(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(import_chalk.default.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(generateUnifiedSummary(results));
+    }
+  } catch (error) {
+    console.error(import_chalk.default.red("\u274C Analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.command("patterns").description("Run pattern detection analysis").argument("<directory>", "Directory to analyze").option("-s, --similarity <number>", "Minimum similarity score (0-1)", "0.40").option("-l, --min-lines <number>", "Minimum lines to consider", "5").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) => {
+  console.log(import_chalk.default.blue("\u{1F50D} Analyzing patterns...\n"));
+  const startTime = Date.now();
+  try {
+    const { analyzePatterns: analyzePatterns2, generateSummary } = await import("@aiready/pattern-detect");
+    const results = await analyzePatterns2({
+      rootDir: directory,
+      minSimilarity: parseFloat(options.similarity),
+      minLines: parseInt(options.minLines),
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    const summary = generateSummary(results);
+    if (options.output === "json") {
+      const outputData = {
+        results,
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+      };
+      if (options.outputFile) {
+        (0, import_fs.writeFileSync)(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(import_chalk.default.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(`Pattern Analysis Complete (${elapsedTime}s)`);
+      console.log(`Found ${summary.totalPatterns} duplicate patterns`);
+      console.log(`Total token cost: ${summary.totalTokenCost} tokens`);
+    }
+  } catch (error) {
+    console.error(import_chalk.default.red("\u274C Pattern analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.command("context").description("Run context window cost analysis").argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth", "5").option("--max-context <number>", "Maximum acceptable context budget (tokens)", "10000").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) => {
+  console.log(import_chalk.default.blue("\u{1F9E0} Analyzing context costs...\n"));
+  const startTime = Date.now();
+  try {
+    const { analyzeContext: analyzeContext2, generateSummary } = await import("@aiready/context-analyzer");
+    const results = await analyzeContext2({
+      rootDir: directory,
+      maxDepth: parseInt(options.maxDepth),
+      maxContextBudget: parseInt(options.maxContext),
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    const summary = generateSummary(results);
+    if (options.output === "json") {
+      const outputData = {
+        results,
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+      };
+      if (options.outputFile) {
+        (0, import_fs.writeFileSync)(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(import_chalk.default.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(`Context Analysis Complete (${elapsedTime}s)`);
+      console.log(`Files analyzed: ${summary.totalFiles}`);
+      console.log(`Issues found: ${results.length}`);
+      console.log(`Average cohesion: ${(summary.avgCohesion * 100).toFixed(1)}%`);
+      console.log(`Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(1)}%`);
+    }
+  } catch (error) {
+    console.error(import_chalk.default.red("\u274C Context analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import {
+  analyzeUnified,
+  generateUnifiedSummary
+} from "./chunk-S6JWNLN7.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync } from "fs";
+var program = new Command();
+program.name("aiready").description("AIReady - Unified AI-readiness analysis tools").version("0.1.0");
+program.command("scan").description("Run unified analysis on a codebase").argument("<directory>", "Directory to analyze").option("-t, --tools <tools>", "Tools to run (comma-separated: patterns,context)", "patterns,context").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) => {
+  console.log(chalk.blue("\u{1F680} Starting AIReady unified analysis...\n"));
+  const startTime = Date.now();
+  try {
+    const tools = options.tools.split(",").map((t) => t.trim());
+    const results = await analyzeUnified({
+      rootDir: directory,
+      tools,
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    if (options.output === "json") {
+      const outputData = {
+        ...results,
+        summary: {
+          ...results.summary,
+          executionTime: parseFloat(elapsedTime)
+        }
+      };
+      if (options.outputFile) {
+        writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(chalk.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(generateUnifiedSummary(results));
+    }
+  } catch (error) {
+    console.error(chalk.red("\u274C Analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.command("patterns").description("Run pattern detection analysis").argument("<directory>", "Directory to analyze").option("-s, --similarity <number>", "Minimum similarity score (0-1)", "0.40").option("-l, --min-lines <number>", "Minimum lines to consider", "5").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) => {
+  console.log(chalk.blue("\u{1F50D} Analyzing patterns...\n"));
+  const startTime = Date.now();
+  try {
+    const { analyzePatterns, generateSummary } = await import("@aiready/pattern-detect");
+    const results = await analyzePatterns({
+      rootDir: directory,
+      minSimilarity: parseFloat(options.similarity),
+      minLines: parseInt(options.minLines),
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    const summary = generateSummary(results);
+    if (options.output === "json") {
+      const outputData = {
+        results,
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+      };
+      if (options.outputFile) {
+        writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(chalk.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(`Pattern Analysis Complete (${elapsedTime}s)`);
+      console.log(`Found ${summary.totalPatterns} duplicate patterns`);
+      console.log(`Total token cost: ${summary.totalTokenCost} tokens`);
+    }
+  } catch (error) {
+    console.error(chalk.red("\u274C Pattern analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.command("context").description("Run context window cost analysis").argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth", "5").option("--max-context <number>", "Maximum acceptable context budget (tokens)", "10000").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) => {
+  console.log(chalk.blue("\u{1F9E0} Analyzing context costs...\n"));
+  const startTime = Date.now();
+  try {
+    const { analyzeContext, generateSummary } = await import("@aiready/context-analyzer");
+    const results = await analyzeContext({
+      rootDir: directory,
+      maxDepth: parseInt(options.maxDepth),
+      maxContextBudget: parseInt(options.maxContext),
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(",")
+    });
+    const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+    const summary = generateSummary(results);
+    if (options.output === "json") {
+      const outputData = {
+        results,
+        summary: { ...summary, executionTime: parseFloat(elapsedTime) }
+      };
+      if (options.outputFile) {
+        writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+        console.log(chalk.green(`\u2705 Results saved to ${options.outputFile}`));
+      } else {
+        console.log(JSON.stringify(outputData, null, 2));
+      }
+    } else {
+      console.log(`Context Analysis Complete (${elapsedTime}s)`);
+      console.log(`Files analyzed: ${summary.totalFiles}`);
+      console.log(`Issues found: ${results.length}`);
+      console.log(`Average cohesion: ${(summary.avgCohesion * 100).toFixed(1)}%`);
+      console.log(`Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(1)}%`);
+    }
+  } catch (error) {
+    console.error(chalk.red("\u274C Context analysis failed:"), error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/index.d.mts

@@ -0,0 +1,19 @@
+import { ScanOptions, AnalysisResult } from '@aiready/core';
+import { ContextAnalysisResult } from '@aiready/context-analyzer';
+
+interface UnifiedAnalysisOptions extends ScanOptions {
+    tools?: ('patterns' | 'context')[];
+}
+interface UnifiedAnalysisResult {
+    patterns?: AnalysisResult[];
+    context?: ContextAnalysisResult[];
+    summary: {
+        totalIssues: number;
+        toolsRun: string[];
+        executionTime: number;
+    };
+}
+declare function analyzeUnified(options: UnifiedAnalysisOptions): Promise<UnifiedAnalysisResult>;
+declare function generateUnifiedSummary(result: UnifiedAnalysisResult): string;
+
+export { type UnifiedAnalysisOptions, type UnifiedAnalysisResult, analyzeUnified, generateUnifiedSummary };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { ScanOptions, AnalysisResult } from '@aiready/core';
+import { ContextAnalysisResult } from '@aiready/context-analyzer';
+
+interface UnifiedAnalysisOptions extends ScanOptions {
+    tools?: ('patterns' | 'context')[];
+}
+interface UnifiedAnalysisResult {
+    patterns?: AnalysisResult[];
+    context?: ContextAnalysisResult[];
+    summary: {
+        totalIssues: number;
+        toolsRun: string[];
+        executionTime: number;
+    };
+}
+declare function analyzeUnified(options: UnifiedAnalysisOptions): Promise<UnifiedAnalysisResult>;
+declare function generateUnifiedSummary(result: UnifiedAnalysisResult): string;
+
+export { type UnifiedAnalysisOptions, type UnifiedAnalysisResult, analyzeUnified, generateUnifiedSummary };

package/dist/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  analyzeUnified: () => analyzeUnified,
+  generateUnifiedSummary: () => generateUnifiedSummary
+});
+module.exports = __toCommonJS(index_exports);
+var import_pattern_detect = require("@aiready/pattern-detect");
+var import_context_analyzer = require("@aiready/context-analyzer");
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const tools = options.tools || ["patterns", "context"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0
+    }
+  };
+  if (tools.includes("patterns")) {
+    result.patterns = await (0, import_pattern_detect.analyzePatterns)(options);
+    result.summary.totalIssues += result.patterns.length;
+  }
+  if (tools.includes("context")) {
+    result.context = await (0, import_context_analyzer.analyzeContext)(options);
+    result.summary.totalIssues += result.context?.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?.length) {
+    output += `\u{1F50D} Pattern Analysis: ${result.patterns.length} issues
+`;
+  }
+  if (result.context?.length) {
+    output += `\u{1F9E0} Context Analysis: ${result.context.length} issues
+`;
+  }
+  return output;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeUnified,
+  generateUnifiedSummary
+});

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import {
+  analyzeUnified,
+  generateUnifiedSummary
+} from "./chunk-S6JWNLN7.mjs";
+export {
+  analyzeUnified,
+  generateUnifiedSummary
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@aiready/cli",
+  "version": "0.1.0",
+  "description": "Unified CLI for AIReady analysis tools",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "aiready": "./dist/cli.js"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "@aiready/context-analyzer": "0.1.0",
+    "@aiready/core": "0.2.1",
+    "@aiready/pattern-detect": "0.5.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "@types/node": "^20.0.0"
+  },
+  "keywords": [
+    "aiready",
+    "cli",
+    "ai-readiness",
+    "code-analysis"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "lint": "eslint src",
+    "clean": "rm -rf dist"
+  }
+}

package/src/__tests__/cli.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from 'vitest';
+import { analyzeUnified } from '../index';
+
+// Mock the individual tools
+vi.mock('@aiready/pattern-detect', () => ({
+  analyzePatterns: vi.fn().mockResolvedValue([]),
+  generateSummary: vi.fn().mockReturnValue({
+    totalDuplicateLines: 0,
+    potentialSavings: 0,
+  }),
+}));
+
+vi.mock('@aiready/context-analyzer', () => ({
+  analyzeContext: vi.fn().mockResolvedValue([]),
+  generateSummary: vi.fn().mockReturnValue({
+    totalFiles: 0,
+    averageCohesion: 0,
+    averageFragmentation: 0,
+  }),
+}));
+
+describe('CLI Unified Analysis', () => {
+  it('should run unified analysis with both tools', async () => {
+    const results = await analyzeUnified({
+      rootDir: '/test',
+      tools: ['patterns', 'context'],
+    });
+
+    expect(results).toHaveProperty('patterns');
+    expect(results).toHaveProperty('context');
+    expect(results).toHaveProperty('summary');
+  });
+
+  it('should run analysis with only patterns tool', async () => {
+    const results = await analyzeUnified({
+      rootDir: '/test',
+      tools: ['patterns'],
+    });
+
+    expect(results).toHaveProperty('patterns');
+    expect(results).not.toHaveProperty('context');
+    expect(results).toHaveProperty('summary');
+  });
+
+  it('should run analysis with only context tool', async () => {
+    const results = await analyzeUnified({
+      rootDir: '/test',
+      tools: ['context'],
+    });
+
+    expect(results).not.toHaveProperty('patterns');
+    expect(results).toHaveProperty('context');
+    expect(results).toHaveProperty('summary');
+  });
+});

package/src/cli.ts

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { analyzeUnified, generateUnifiedSummary } from './index';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+const program = new Command();
+
+program
+  .name('aiready')
+  .description('AIReady - Unified AI-readiness analysis tools')
+  .version('0.1.0');
+
+program
+  .command('scan')
+  .description('Run unified analysis on a codebase')
+  .argument('<directory>', 'Directory to analyze')
+  .option('-t, --tools <tools>', 'Tools to run (comma-separated: patterns,context)', 'patterns,context')
+  .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) => {
+    console.log(chalk.blue('🚀 Starting AIReady unified analysis...\n'));
+
+    const startTime = Date.now();
+
+    try {
+      const tools = options.tools.split(',').map((t: string) => t.trim()) as ('patterns' | 'context')[];
+
+      const results = await analyzeUnified({
+        rootDir: directory,
+        tools,
+        include: options.include?.split(','),
+        exclude: options.exclude?.split(','),
+      });
+
+      const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
+
+      if (options.output === 'json') {
+        const outputData = {
+          ...results,
+          summary: {
+            ...results.summary,
+            executionTime: parseFloat(elapsedTime),
+          },
+        };
+
+        if (options.outputFile) {
+          writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+          console.log(chalk.green(`✅ Results saved to ${options.outputFile}`));
+        } else {
+          console.log(JSON.stringify(outputData, null, 2));
+        }
+      } else {
+        // Console output
+        console.log(generateUnifiedSummary(results));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Analysis failed:'), error);
+      process.exit(1);
+    }
+  });
+
+// Individual tool commands for convenience
+program
+  .command('patterns')
+  .description('Run pattern detection analysis')
+  .argument('<directory>', 'Directory to analyze')
+  .option('-s, --similarity <number>', 'Minimum similarity score (0-1)', '0.40')
+  .option('-l, --min-lines <number>', 'Minimum lines to consider', '5')
+  .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) => {
+    console.log(chalk.blue('🔍 Analyzing patterns...\n'));
+
+    const startTime = Date.now();
+
+    try {
+      const { analyzePatterns, generateSummary } = await import('@aiready/pattern-detect');
+
+      const results = await analyzePatterns({
+        rootDir: directory,
+        minSimilarity: parseFloat(options.similarity),
+        minLines: parseInt(options.minLines),
+        include: options.include?.split(','),
+        exclude: options.exclude?.split(','),
+      });
+
+      const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
+      const summary = generateSummary(results);
+
+      if (options.output === 'json') {
+        const outputData = {
+          results,
+          summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        };
+
+        if (options.outputFile) {
+          writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+          console.log(chalk.green(`✅ Results saved to ${options.outputFile}`));
+        } else {
+          console.log(JSON.stringify(outputData, null, 2));
+        }
+      } else {
+        console.log(`Pattern Analysis Complete (${elapsedTime}s)`);
+        console.log(`Found ${summary.totalPatterns} duplicate patterns`);
+        console.log(`Total token cost: ${summary.totalTokenCost} tokens`);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Pattern analysis failed:'), error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('context')
+  .description('Run context window cost analysis')
+  .argument('<directory>', 'Directory to analyze')
+  .option('--max-depth <number>', 'Maximum acceptable import depth', '5')
+  .option('--max-context <number>', 'Maximum acceptable context budget (tokens)', '10000')
+  .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) => {
+    console.log(chalk.blue('🧠 Analyzing context costs...\n'));
+
+    const startTime = Date.now();
+
+    try {
+      const { analyzeContext, generateSummary } = await import('@aiready/context-analyzer');
+
+      const results = await analyzeContext({
+        rootDir: directory,
+        maxDepth: parseInt(options.maxDepth),
+        maxContextBudget: parseInt(options.maxContext),
+        include: options.include?.split(','),
+        exclude: options.exclude?.split(','),
+      });
+
+      const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
+      const summary = generateSummary(results);
+
+      if (options.output === 'json') {
+        const outputData = {
+          results,
+          summary: { ...summary, executionTime: parseFloat(elapsedTime) },
+        };
+
+        if (options.outputFile) {
+          writeFileSync(options.outputFile, JSON.stringify(outputData, null, 2));
+          console.log(chalk.green(`✅ Results saved to ${options.outputFile}`));
+        } else {
+          console.log(JSON.stringify(outputData, null, 2));
+        }
+      } else {
+        console.log(`Context Analysis Complete (${elapsedTime}s)`);
+        console.log(`Files analyzed: ${summary.totalFiles}`);
+        console.log(`Issues found: ${results.length}`);
+        console.log(`Average cohesion: ${(summary.avgCohesion * 100).toFixed(1)}%`);
+        console.log(`Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(1)}%`);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Context analysis failed:'), error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/index.ts

@@ -0,0 +1,66 @@
+import { analyzePatterns } from '@aiready/pattern-detect';
+import { analyzeContext } from '@aiready/context-analyzer';
+import type { AnalysisResult, ScanOptions } from '@aiready/core';
+import type { ContextAnalysisResult } from '@aiready/context-analyzer';
+
+export interface UnifiedAnalysisOptions extends ScanOptions {
+  tools?: ('patterns' | 'context')[];
+}
+
+export interface UnifiedAnalysisResult {
+  patterns?: AnalysisResult[];
+  context?: ContextAnalysisResult[];
+  summary: {
+    totalIssues: number;
+    toolsRun: string[];
+    executionTime: number;
+  };
+}
+
+export async function analyzeUnified(
+  options: UnifiedAnalysisOptions
+): Promise<UnifiedAnalysisResult> {
+  const startTime = Date.now();
+  const tools = options.tools || ['patterns', 'context'];
+  const result: UnifiedAnalysisResult = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: tools,
+      executionTime: 0,
+    },
+  };
+
+  // Run pattern detection
+  if (tools.includes('patterns')) {
+    result.patterns = await analyzePatterns(options);
+    result.summary.totalIssues += result.patterns.length;
+  }
+
+  // Run context analysis
+  if (tools.includes('context')) {
+    result.context = await analyzeContext(options);
+    result.summary.totalIssues += result.context?.length || 0;
+  }
+
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+
+export function generateUnifiedSummary(result: UnifiedAnalysisResult): string {
+  const { summary } = result;
+  let output = `🚀 AIReady Analysis Complete\n\n`;
+  output += `📊 Summary:\n`;
+  output += `   Tools run: ${summary.toolsRun.join(', ')}\n`;
+  output += `   Total issues found: ${summary.totalIssues}\n`;
+  output += `   Execution time: ${(summary.executionTime / 1000).toFixed(2)}s\n\n`;
+
+  if (result.patterns?.length) {
+    output += `🔍 Pattern Analysis: ${result.patterns.length} issues\n`;
+  }
+
+  if (result.context?.length) {
+    output += `🧠 Context Analysis: ${result.context.length} issues\n`;
+  }
+
+  return output;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../core/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}