@aiready/core 0.24.6 → 0.24.8

package/dist/index.js

@@ -2214,66 +2214,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types/business.ts
-var import_zod = require("zod");
-var LeadSource = /* @__PURE__ */ ((LeadSource2) => {
-  LeadSource2["ClawMoreHero"] = "clawmore-hero";
-  LeadSource2["ClawMoreWaitlist"] = "clawmore-waitlist";
-  LeadSource2["ClawMoreBeta"] = "clawmore-beta";
-  LeadSource2["AiReadyPlatform"] = "aiready-platform";
-  return LeadSource2;
-})(LeadSource || {});
-var LeadSourceSchema = import_zod.z.nativeEnum(LeadSource);
-var LeadSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  email: import_zod.z.string().email(),
-  name: import_zod.z.string().min(1),
-  interest: import_zod.z.string().default("General"),
-  notes: import_zod.z.string().optional(),
-  timestamp: import_zod.z.string().datetime(),
-  source: LeadSourceSchema,
-  status: import_zod.z.enum(["new", "contacted", "qualified", "converted", "archived"]).default("new")
-});
-var LeadSubmissionSchema = LeadSchema.omit({
-  id: true,
-  timestamp: true,
-  status: true
-});
-var ManagedAccountSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  // Internal UUID
-  accountId: import_zod.z.string(),
-  // AWS Account ID
-  userId: import_zod.z.string(),
-  // Owner (caopengau@gmail.com)
-  stripeSubscriptionId: import_zod.z.string(),
-  // AI Token Management
-  tokenStrategy: import_zod.z.enum(["managed", "byok"]).default("managed"),
-  byokConfig: import_zod.z.object({
-    openaiKey: import_zod.z.string().optional(),
-    anthropicKey: import_zod.z.string().optional(),
-    openrouterKey: import_zod.z.string().optional()
-  }).optional(),
-  // Financials (in cents)
-  baseFeeCents: import_zod.z.number().default(2900),
-  includedComputeCents: import_zod.z.number().default(1500),
-  // $15.00 AWS included
-  includedTokenCents: import_zod.z.number().default(500),
-  // $5.00 Managed Tokens included
-  // Pre-paid Balance (credits)
-  prepaidTokenBalanceCents: import_zod.z.number().default(0),
-  // Users buy these in $10 packs
-  currentMonthlyTokenSpendCents: import_zod.z.number().default(0),
-  // Governance
-  status: import_zod.z.enum(["provisioning", "active", "warning", "quarantined", "suspended"]).default("provisioning"),
-  lastCostSyncAt: import_zod.z.string().datetime().optional(),
-  region: import_zod.z.string().default("ap-southeast-2"),
-  // Alerting thresholds (percentage of includedComputeCents)
-  alertThresholds: import_zod.z.array(import_zod.z.number()).default([50, 80, 100, 150])
-});
-
 // src/types/enums.ts
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 var Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Critical"] = "critical";
   Severity2["Major"] = "major";
@@ -2281,7 +2223,7 @@ var Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Info"] = "info";
   return Severity2;
 })(Severity || {});
-var SeveritySchema = import_zod2.z.nativeEnum(Severity);
+var SeveritySchema = import_zod.z.nativeEnum(Severity);
 var ToolName = /* @__PURE__ */ ((ToolName2) => {
   ToolName2["PatternDetect"] = "pattern-detect";
   ToolName2["ContextAnalyzer"] = "context-analyzer";
@@ -2299,7 +2241,7 @@ var ToolName = /* @__PURE__ */ ((ToolName2) => {
   ToolName2["ContractEnforcement"] = "contract-enforcement";
   return ToolName2;
 })(ToolName || {});
-var ToolNameSchema = import_zod2.z.nativeEnum(ToolName);
+var ToolNameSchema = import_zod.z.nativeEnum(ToolName);
 var FRIENDLY_TOOL_NAMES = {
   ["pattern-detect" /* PatternDetect */]: "Semantic Duplicates",
   ["context-analyzer" /* ContextAnalyzer */]: "Context Fragmentation",
@@ -2338,14 +2280,14 @@ var IssueType = /* @__PURE__ */ ((IssueType2) => {
   IssueType2["ContractGap"] = "contract-gap";
   return IssueType2;
 })(IssueType || {});
-var IssueTypeSchema = import_zod2.z.nativeEnum(IssueType);
+var IssueTypeSchema = import_zod.z.nativeEnum(IssueType);
 var AnalysisStatus = /* @__PURE__ */ ((AnalysisStatus2) => {
   AnalysisStatus2["Processing"] = "processing";
   AnalysisStatus2["Completed"] = "completed";
   AnalysisStatus2["Failed"] = "failed";
   return AnalysisStatus2;
 })(AnalysisStatus || {});
-var AnalysisStatusSchema = import_zod2.z.nativeEnum(AnalysisStatus);
+var AnalysisStatusSchema = import_zod.z.nativeEnum(AnalysisStatus);
 var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Compact"] = "compact";
   ModelTier2["Standard"] = "standard";
@@ -2353,149 +2295,207 @@ var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Frontier"] = "frontier";
   return ModelTier2;
 })(ModelTier || {});
-var ModelTierSchema = import_zod2.z.nativeEnum(ModelTier);
+var ModelTierSchema = import_zod.z.nativeEnum(ModelTier);
 
 // src/types/common.ts
-var import_zod3 = require("zod");
-var LocationSchema = import_zod3.z.object({
-  file: import_zod3.z.string(),
-  line: import_zod3.z.number(),
-  column: import_zod3.z.number().optional(),
-  endLine: import_zod3.z.number().optional(),
-  endColumn: import_zod3.z.number().optional()
+var import_zod2 = require("zod");
+var LocationSchema = import_zod2.z.object({
+  file: import_zod2.z.string(),
+  line: import_zod2.z.number(),
+  column: import_zod2.z.number().optional(),
+  endLine: import_zod2.z.number().optional(),
+  endColumn: import_zod2.z.number().optional()
 });
 
 // src/types/schemas/issue.ts
-var import_zod4 = require("zod");
-var IssueSchema = import_zod4.z.object({
+var import_zod3 = require("zod");
+var IssueSchema = import_zod3.z.object({
   type: IssueTypeSchema,
   severity: SeveritySchema,
-  message: import_zod4.z.string(),
+  message: import_zod3.z.string(),
   location: LocationSchema,
-  suggestion: import_zod4.z.string().optional()
+  suggestion: import_zod3.z.string().optional()
 });
 
 // src/types/schemas/metrics.ts
-var import_zod5 = require("zod");
-var MetricsSchema = import_zod5.z.object({
-  tokenCost: import_zod5.z.number().optional(),
-  complexityScore: import_zod5.z.number().optional(),
-  consistencyScore: import_zod5.z.number().optional(),
-  docFreshnessScore: import_zod5.z.number().optional(),
+var import_zod4 = require("zod");
+var MetricsSchema = import_zod4.z.object({
+  tokenCost: import_zod4.z.number().optional(),
+  complexityScore: import_zod4.z.number().optional(),
+  consistencyScore: import_zod4.z.number().optional(),
+  docFreshnessScore: import_zod4.z.number().optional(),
   // AI agent readiness metrics (v0.12+)
-  aiSignalClarityScore: import_zod5.z.number().optional(),
-  agentGroundingScore: import_zod5.z.number().optional(),
-  testabilityScore: import_zod5.z.number().optional(),
-  docDriftScore: import_zod5.z.number().optional(),
-  dependencyHealthScore: import_zod5.z.number().optional(),
+  aiSignalClarityScore: import_zod4.z.number().optional(),
+  agentGroundingScore: import_zod4.z.number().optional(),
+  testabilityScore: import_zod4.z.number().optional(),
+  docDriftScore: import_zod4.z.number().optional(),
+  dependencyHealthScore: import_zod4.z.number().optional(),
   modelContextTier: ModelTierSchema.optional(),
   // Business value metrics
-  estimatedMonthlyCost: import_zod5.z.number().optional(),
-  estimatedDeveloperHours: import_zod5.z.number().optional(),
-  comprehensionDifficultyIndex: import_zod5.z.number().optional(),
+  estimatedMonthlyCost: import_zod4.z.number().optional(),
+  estimatedDeveloperHours: import_zod4.z.number().optional(),
+  comprehensionDifficultyIndex: import_zod4.z.number().optional(),
   // Extended metrics for specific spokes
-  totalSymbols: import_zod5.z.number().optional(),
-  totalExports: import_zod5.z.number().optional()
+  totalSymbols: import_zod4.z.number().optional(),
+  totalExports: import_zod4.z.number().optional()
 });
 
 // src/types/schemas/report.ts
-var import_zod6 = require("zod");
-var AnalysisResultSchema = import_zod6.z.object({
-  fileName: import_zod6.z.string(),
-  issues: import_zod6.z.array(IssueSchema),
+var import_zod5 = require("zod");
+var AnalysisResultSchema = import_zod5.z.object({
+  fileName: import_zod5.z.string(),
+  issues: import_zod5.z.array(IssueSchema),
   metrics: MetricsSchema
 });
-var SpokeSummarySchema = import_zod6.z.object({
-  totalFiles: import_zod6.z.number().optional(),
-  totalIssues: import_zod6.z.number().optional(),
-  criticalIssues: import_zod6.z.number().optional(),
-  majorIssues: import_zod6.z.number().optional(),
-  score: import_zod6.z.number().optional()
-}).catchall(import_zod6.z.any());
-var SpokeOutputSchema = import_zod6.z.object({
-  results: import_zod6.z.array(AnalysisResultSchema),
+var SpokeSummarySchema = import_zod5.z.object({
+  totalFiles: import_zod5.z.number().optional(),
+  totalIssues: import_zod5.z.number().optional(),
+  criticalIssues: import_zod5.z.number().optional(),
+  majorIssues: import_zod5.z.number().optional(),
+  score: import_zod5.z.number().optional()
+}).catchall(import_zod5.z.any());
+var SpokeOutputSchema = import_zod5.z.object({
+  results: import_zod5.z.array(AnalysisResultSchema),
   summary: SpokeSummarySchema,
-  metadata: import_zod6.z.object({
-    toolName: import_zod6.z.string(),
-    version: import_zod6.z.string().optional(),
-    timestamp: import_zod6.z.string().optional(),
-    config: import_zod6.z.any().optional()
-  }).catchall(import_zod6.z.any()).optional()
+  metadata: import_zod5.z.object({
+    toolName: import_zod5.z.string(),
+    version: import_zod5.z.string().optional(),
+    timestamp: import_zod5.z.string().optional(),
+    config: import_zod5.z.any().optional()
+  }).catchall(import_zod5.z.any()).optional()
 });
-var UnifiedReportSchema = import_zod6.z.object({
-  summary: import_zod6.z.object({
-    totalFiles: import_zod6.z.number(),
-    totalIssues: import_zod6.z.number(),
-    criticalIssues: import_zod6.z.number(),
-    majorIssues: import_zod6.z.number(),
-    businessImpact: import_zod6.z.object({
-      estimatedMonthlyWaste: import_zod6.z.number().optional(),
-      potentialSavings: import_zod6.z.number().optional(),
-      productivityHours: import_zod6.z.number().optional()
+var UnifiedReportSchema = import_zod5.z.object({
+  summary: import_zod5.z.object({
+    totalFiles: import_zod5.z.number(),
+    totalIssues: import_zod5.z.number(),
+    criticalIssues: import_zod5.z.number(),
+    majorIssues: import_zod5.z.number(),
+    businessImpact: import_zod5.z.object({
+      estimatedMonthlyWaste: import_zod5.z.number().optional(),
+      potentialSavings: import_zod5.z.number().optional(),
+      productivityHours: import_zod5.z.number().optional()
     }).optional()
   }),
-  results: import_zod6.z.array(AnalysisResultSchema),
-  scoring: import_zod6.z.object({
-    overall: import_zod6.z.number(),
-    rating: import_zod6.z.string(),
-    timestamp: import_zod6.z.string(),
-    breakdown: import_zod6.z.array(
-      import_zod6.z.object({
-        toolName: import_zod6.z.union([ToolNameSchema, import_zod6.z.string()]),
-        score: import_zod6.z.number()
-      }).catchall(import_zod6.z.any())
+  results: import_zod5.z.array(AnalysisResultSchema),
+  scoring: import_zod5.z.object({
+    overall: import_zod5.z.number(),
+    rating: import_zod5.z.string(),
+    timestamp: import_zod5.z.string(),
+    breakdown: import_zod5.z.array(
+      import_zod5.z.object({
+        toolName: import_zod5.z.union([ToolNameSchema, import_zod5.z.string()]),
+        score: import_zod5.z.number()
+      }).catchall(import_zod5.z.any())
     )
   }).optional()
-}).catchall(import_zod6.z.any());
+}).catchall(import_zod5.z.any());
 
 // src/types/schemas/config.ts
-var import_zod7 = require("zod");
-var AIReadyConfigSchema = import_zod7.z.object({
+var import_zod6 = require("zod");
+var AIReadyConfigSchema = import_zod6.z.object({
   /** Files or directories to exclude from scan */
-  exclude: import_zod7.z.array(import_zod7.z.string()).optional(),
+  exclude: import_zod6.z.array(import_zod6.z.string()).optional(),
   /** Fail CI/CD if score below threshold (0-100) */
-  threshold: import_zod7.z.number().optional(),
+  threshold: import_zod6.z.number().optional(),
   /** Fail on issues: critical, major, any */
-  failOn: import_zod7.z.enum(["critical", "major", "any", "none"]).optional(),
+  failOn: import_zod6.z.enum(["critical", "major", "any", "none"]).optional(),
   /** Scan-specific configuration */
-  scan: import_zod7.z.object({
-    include: import_zod7.z.array(import_zod7.z.string()).optional(),
-    exclude: import_zod7.z.array(import_zod7.z.string()).optional(),
-    parallel: import_zod7.z.boolean().optional(),
-    deep: import_zod7.z.boolean().optional(),
-    tools: import_zod7.z.array(import_zod7.z.string()).optional()
+  scan: import_zod6.z.object({
+    include: import_zod6.z.array(import_zod6.z.string()).optional(),
+    exclude: import_zod6.z.array(import_zod6.z.string()).optional(),
+    parallel: import_zod6.z.boolean().optional(),
+    deep: import_zod6.z.boolean().optional(),
+    tools: import_zod6.z.array(import_zod6.z.string()).optional()
   }).optional(),
   /** Output-specific configuration */
-  output: import_zod7.z.object({
+  output: import_zod6.z.object({
     /** Output format (json, console, html) */
-    format: import_zod7.z.enum(["json", "console", "html"]).optional(),
+    format: import_zod6.z.enum(["json", "console", "html"]).optional(),
     /** Output file path */
-    path: import_zod7.z.string().optional(),
+    path: import_zod6.z.string().optional(),
     /** Output directory */
-    saveTo: import_zod7.z.string().optional(),
+    saveTo: import_zod6.z.string().optional(),
     /** Whether to show score breakdown in console */
-    showBreakdown: import_zod7.z.boolean().optional(),
+    showBreakdown: import_zod6.z.boolean().optional(),
     /** Baseline report to compare against */
-    compareBaseline: import_zod7.z.string().optional()
+    compareBaseline: import_zod6.z.string().optional()
   }).optional(),
   /** Tool-specific configuration overrides (Strictly ToolName -> Config) */
-  tools: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.any()).optional(),
+  tools: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.any()).optional(),
   /** Scoring profile and weights */
-  scoring: import_zod7.z.object({
+  scoring: import_zod6.z.object({
     /** Name of the scoring profile (e.g. "strict", "balanced") */
-    profile: import_zod7.z.string().optional(),
+    profile: import_zod6.z.string().optional(),
     /** Custom weights for tools and metrics */
-    weights: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number()).optional()
+    weights: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.number()).optional()
   }).optional(),
   /** Visualizer settings (interactive graph) */
-  visualizer: import_zod7.z.object({
-    groupingDirs: import_zod7.z.array(import_zod7.z.string()).optional(),
-    graph: import_zod7.z.object({
-      maxNodes: import_zod7.z.number().optional(),
-      maxEdges: import_zod7.z.number().optional()
+  visualizer: import_zod6.z.object({
+    groupingDirs: import_zod6.z.array(import_zod6.z.string()).optional(),
+    graph: import_zod6.z.object({
+      maxNodes: import_zod6.z.number().optional(),
+      maxEdges: import_zod6.z.number().optional()
     }).optional()
   }).optional()
-}).catchall(import_zod7.z.any());
+}).catchall(import_zod6.z.any());
+
+// src/types/business.ts
+var import_zod7 = require("zod");
+var LeadSource = /* @__PURE__ */ ((LeadSource2) => {
+  LeadSource2["ClawMoreHero"] = "clawmore-hero";
+  LeadSource2["ClawMoreWaitlist"] = "clawmore-waitlist";
+  LeadSource2["ClawMoreBeta"] = "clawmore-beta";
+  LeadSource2["AiReadyPlatform"] = "aiready-platform";
+  return LeadSource2;
+})(LeadSource || {});
+var LeadSourceSchema = import_zod7.z.nativeEnum(LeadSource);
+var LeadSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  email: import_zod7.z.string().email(),
+  name: import_zod7.z.string().min(1),
+  interest: import_zod7.z.string().default("General"),
+  notes: import_zod7.z.string().optional(),
+  timestamp: import_zod7.z.string().datetime(),
+  source: LeadSourceSchema,
+  status: import_zod7.z.enum(["new", "contacted", "qualified", "converted", "archived"]).default("new")
+});
+var LeadSubmissionSchema = LeadSchema.omit({
+  id: true,
+  timestamp: true,
+  status: true
+});
+var ManagedAccountSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  // Internal UUID
+  accountId: import_zod7.z.string(),
+  // AWS Account ID
+  userId: import_zod7.z.string(),
+  // Owner (caopengau@gmail.com)
+  stripeSubscriptionId: import_zod7.z.string(),
+  // AI Token Management
+  tokenStrategy: import_zod7.z.enum(["managed", "byok"]).default("managed"),
+  byokConfig: import_zod7.z.object({
+    openaiKey: import_zod7.z.string().optional(),
+    anthropicKey: import_zod7.z.string().optional(),
+    openrouterKey: import_zod7.z.string().optional()
+  }).optional(),
+  // Financials (in cents)
+  baseFeeCents: import_zod7.z.number().default(2900),
+  includedComputeCents: import_zod7.z.number().default(1500),
+  // $15.00 AWS included
+  includedTokenCents: import_zod7.z.number().default(500),
+  // $5.00 Managed Tokens included
+  // Pre-paid Balance (credits)
+  prepaidTokenBalanceCents: import_zod7.z.number().default(0),
+  // Users buy these in $10 packs
+  currentMonthlyTokenSpendCents: import_zod7.z.number().default(0),
+  // Governance
+  status: import_zod7.z.enum(["provisioning", "active", "warning", "quarantined", "suspended"]).default("provisioning"),
+  lastCostSyncAt: import_zod7.z.string().datetime().optional(),
+  region: import_zod7.z.string().default("ap-southeast-2"),
+  // Alerting thresholds (percentage of includedComputeCents)
+  alertThresholds: import_zod7.z.array(import_zod7.z.number()).default([50, 80, 100, 150])
+});
 
 // src/types.ts
 var GLOBAL_INFRA_OPTIONS = [
@@ -3560,7 +3560,7 @@ function extractExportsWithDependencies(ast, fileImports) {
         type: "default",
         imports: usedImports,
         dependencies: [],
-        typeReferences: [],
+        typeReferences,
         loc: node.loc
       });
     } else if (node.type === "ExportAllDeclaration") {
@@ -3810,15 +3810,19 @@ function mergeConfigWithDefaults(userConfig, defaults) {
     if (!mergedConfig.toolConfigs) mergedConfig.toolConfigs = {};
     for (const [toolName, toolConfig] of Object.entries(userConfig.tools)) {
       if (typeof toolConfig === "object" && toolConfig !== null) {
-        mergedConfig.toolConfigs[toolName] = {
-          ...mergedConfig.toolConfigs[toolName],
+        const toolConfigs = mergedConfig.toolConfigs;
+        toolConfigs[toolName] = {
+          ...toolConfigs[toolName],
           ...toolConfig
         };
       }
     }
   }
   if (userConfig.output) {
-    mergedConfig.output = { ...mergedConfig.output, ...userConfig.output };
+    mergedConfig.output = {
+      ...mergedConfig.output,
+      ...userConfig.output
+    };
   }
   return mergedConfig;
 }
@@ -4357,6 +4361,7 @@ var TOOL_NAME_MAP = {
   context: "context-analyzer" /* ContextAnalyzer */,
   "context-analyzer": "context-analyzer" /* ContextAnalyzer */,
   consistency: "naming-consistency" /* NamingConsistency */,
+  namingconsistency: "naming-consistency" /* NamingConsistency */,
   "naming-consistency": "naming-consistency" /* NamingConsistency */,
   "ai-signal": "ai-signal-clarity" /* AiSignalClarity */,
   "ai-signal-clarity": "ai-signal-clarity" /* AiSignalClarity */,
@@ -6546,23 +6551,27 @@ async function executeSpokeCli(name, description, options, analyzeFn) {
   console.log(import_chalk6.default.cyan(`Analyzing ${description.toLowerCase()}...`));
   try {
     const report = await analyzeFn({
-      rootDir: process.cwd(),
-      ...options
+      ...options,
+      rootDir: options.rootDir ?? process.cwd()
     });
     console.log(import_chalk6.default.bold(`
 ${name} Analysis Results:`));
+    const reportRecord = report;
+    const summary = reportRecord.summary;
     console.log(
-      `Rating: ${report.summary.rating.toUpperCase()} (Score: ${report.summary.score})`
+      `Rating: ${summary.rating.toUpperCase()} (Score: ${summary.score})`
     );
-    if (report.issues && report.issues.length > 0) {
+    const issues = reportRecord.issues;
+    if (issues && issues.length > 0) {
       console.log(import_chalk6.default.red(`
-Found ${report.issues.length} issues.`));
+Found ${issues.length} issues.`));
     } else {
       console.log(import_chalk6.default.green("\nNo issues detected."));
     }
     return report;
   } catch (err) {
-    console.error(import_chalk6.default.red(`Error during ${name} analysis: ${err.message}`));
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    console.error(import_chalk6.default.red(`Error during ${name} analysis: ${errorMessage}`));
     process.exit(1);
   }
 }

package/dist/index.mjs

@@ -52,7 +52,7 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-FAESSLG7.mjs";
+} from "./chunk-LRM26BOB.mjs";
 import {
   TypeScriptParser
 } from "./chunk-5IVDH26E.mjs";
@@ -1116,7 +1116,7 @@ function extractExportsWithDependencies(ast, fileImports) {
         type: "default",
         imports: usedImports,
         dependencies: [],
-        typeReferences: [],
+        typeReferences,
         loc: node.loc
       });
     } else if (node.type === "ExportAllDeclaration") {
@@ -1366,15 +1366,19 @@ function mergeConfigWithDefaults(userConfig, defaults) {
     if (!mergedConfig.toolConfigs) mergedConfig.toolConfigs = {};
     for (const [toolName, toolConfig] of Object.entries(userConfig.tools)) {
       if (typeof toolConfig === "object" && toolConfig !== null) {
-        mergedConfig.toolConfigs[toolName] = {
-          ...mergedConfig.toolConfigs[toolName],
+        const toolConfigs = mergedConfig.toolConfigs;
+        toolConfigs[toolName] = {
+          ...toolConfigs[toolName],
           ...toolConfig
         };
       }
     }
   }
   if (userConfig.output) {
-    mergedConfig.output = { ...mergedConfig.output, ...userConfig.output };
+    mergedConfig.output = {
+      ...mergedConfig.output,
+      ...userConfig.output
+    };
   }
   return mergedConfig;
 }
@@ -3571,23 +3575,27 @@ async function executeSpokeCli(name, description, options, analyzeFn) {
   console.log(chalk6.cyan(`Analyzing ${description.toLowerCase()}...`));
   try {
     const report = await analyzeFn({
-      rootDir: process.cwd(),
-      ...options
+      ...options,
+      rootDir: options.rootDir ?? process.cwd()
     });
     console.log(chalk6.bold(`
 ${name} Analysis Results:`));
+    const reportRecord = report;
+    const summary = reportRecord.summary;
     console.log(
-      `Rating: ${report.summary.rating.toUpperCase()} (Score: ${report.summary.score})`
+      `Rating: ${summary.rating.toUpperCase()} (Score: ${summary.score})`
     );
-    if (report.issues && report.issues.length > 0) {
+    const issues = reportRecord.issues;
+    if (issues && issues.length > 0) {
       console.log(chalk6.red(`
-Found ${report.issues.length} issues.`));
+Found ${issues.length} issues.`));
     } else {
       console.log(chalk6.green("\nNo issues detected."));
     }
     return report;
   } catch (err) {
-    console.error(chalk6.red(`Error during ${name} analysis: ${err.message}`));
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    console.error(chalk6.red(`Error during ${name} analysis: ${errorMessage}`));
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.24.6",
+  "version": "0.24.8",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -62,6 +62,8 @@
     "test": "vitest run --hookTimeout=30000",
     "lint": "eslint src",
     "clean": "rm -rf dist",
-    "release": "pnpm build && pnpm publish --no-git-checks"
+    "release": "pnpm build && pnpm publish --no-git-checks",
+    "type-check": "tsc --noEmit",
+    "format-check": "prettier --check . --ignore-path ../../.prettierignore"
   }
 }