@aiready/core 0.23.15 → 0.23.20

package/dist/client.d.mts

@@ -1,2 +1,2 @@
-export { e as AIReadyConfig, h as AcceptancePrediction, A as AnalysisResult, r as AnalysisStatus, B as BusinessMetrics, t as COMMON_FINE_TUNING_OPTIONS, u as CONTEXT_TIER_THRESHOLDS, v as CommonASTNode, i as ComprehensionDifficulty, w as Config, C as CostConfig, D as DEFAULT_TOOL_WEIGHTS, n as ExportInfo, x as FRIENDLY_TOOL_NAMES, y as FileContent, G as GLOBAL_INFRA_OPTIONS, z as GLOBAL_SCAN_OPTIONS, H as GraphData, J as GraphEdge, K as GraphIssueSeverity, O as GraphMetadata, Q as GraphNode, I as Issue, U as IssueType, W as LANGUAGE_EXTENSIONS, l as Language, X as LanguageConfig, L as LanguageParser, Y as Lead, Z as LeadSchema, _ as LeadSource, $ as LeadSourceSchema, a0 as LeadSubmission, a1 as LeadSubmissionSchema, a2 as Location, M as Metrics, f as ModelContextTier, N as NamingConvention, a9 as ParseError, m as ParseResult, aa as ParseStatistics, P as ProductivityImpact, ab as ReadinessRating, ac as RecommendationPriority, ad as SCORING_PROFILES, ae as SIZE_ADJUSTED_THRESHOLDS, S as ScanOptions, af as ScanResult, ag as ScoringConfig, ah as ScoringProfile, ai as ScoringResult, d as Severity, d as SeverityType, ak as SourceLocation, al as SourceRange, a as SpokeOutput, ap as TOOL_NAME_MAP, k as TechnicalValueChain, j as TechnicalValueChainSummary, g as TokenBudget, T as ToolName, c as ToolOptions, ar as ToolOutput, b as ToolScoringOutput, as as UnifiedReport, at as UnifiedReportSchema, au as calculateOverallScore, av as formatScore, aw as formatToolScore, ax as generateHTML, ay as getProjectSizeTier, az as getRating, aA as getRatingDisplay, aB as getRatingSlug, aC as getRatingWithContext, aD as getRecommendedThreshold, aE as getToolWeight, aF as normalizeToolName, aG as parseWeightString } from './client-WVCAIWdJ.mjs';
+export { e as AIReadyConfig, o as AIReadyConfigSchema, h as AcceptancePrediction, A as AnalysisResult, q as AnalysisResultSchema, r as AnalysisStatus, s as AnalysisStatusSchema, aL as BaseGraphLink, aM as BaseGraphNode, B as BusinessMetrics, t as COMMON_FINE_TUNING_OPTIONS, u as CONTEXT_TIER_THRESHOLDS, v as CommonASTNode, i as ComprehensionDifficulty, w as Config, C as CostConfig, D as DEFAULT_TOOL_WEIGHTS, n as ExportInfo, x as FRIENDLY_TOOL_NAMES, y as FileContent, G as GLOBAL_INFRA_OPTIONS, z as GLOBAL_SCAN_OPTIONS, H as GraphData, J as GraphEdge, K as GraphIssueSeverity, O as GraphMetadata, Q as GraphNode, I as Issue, R as IssueSchema, U as IssueType, V as IssueTypeSchema, W as LANGUAGE_EXTENSIONS, l as Language, X as LanguageConfig, L as LanguageParser, Y as Lead, Z as LeadSchema, _ as LeadSource, $ as LeadSourceSchema, a0 as LeadSubmission, a1 as LeadSubmissionSchema, a2 as Location, a3 as LocationSchema, M as Metrics, a6 as MetricsSchema, f as ModelContextTier, a7 as ModelTier, a8 as ModelTierSchema, N as NamingConvention, a9 as ParseError, m as ParseResult, aa as ParseStatistics, P as ProductivityImpact, ac as RecommendationPriority, ad as SCORING_PROFILES, ae as SIZE_ADJUSTED_THRESHOLDS, S as ScanOptions, af as ScanResult, ag as ScoringConfig, ah as ScoringProfile, ai as ScoringResult, d as Severity, aj as SeveritySchema, d as SeverityType, ak as SourceLocation, al as SourceRange, a as SpokeOutput, am as SpokeOutputSchema, an as SpokeSummary, ao as SpokeSummarySchema, ap as TOOL_NAME_MAP, k as TechnicalValueChain, j as TechnicalValueChainSummary, g as TokenBudget, T as ToolName, aq as ToolNameSchema, c as ToolOptions, ar as ToolOutput, b as ToolScoringOutput, as as UnifiedReport, at as UnifiedReportSchema, au as calculateOverallScore, av as formatScore, aw as formatToolScore, ax as generateHTML, az as getProjectSizeTier, aA as getRating, aB as getRatingDisplay, aE as getRatingSlug, aF as getRatingWithContext, aG as getRecommendedThreshold, aI as getToolWeight, aJ as normalizeToolName, aK as parseWeightString } from './client-jGuH6TAG.mjs';
 import 'zod';

package/dist/client.d.ts

@@ -1,2 +1,2 @@
-export { e as AIReadyConfig, h as AcceptancePrediction, A as AnalysisResult, r as AnalysisStatus, B as BusinessMetrics, t as COMMON_FINE_TUNING_OPTIONS, u as CONTEXT_TIER_THRESHOLDS, v as CommonASTNode, i as ComprehensionDifficulty, w as Config, C as CostConfig, D as DEFAULT_TOOL_WEIGHTS, n as ExportInfo, x as FRIENDLY_TOOL_NAMES, y as FileContent, G as GLOBAL_INFRA_OPTIONS, z as GLOBAL_SCAN_OPTIONS, H as GraphData, J as GraphEdge, K as GraphIssueSeverity, O as GraphMetadata, Q as GraphNode, I as Issue, U as IssueType, W as LANGUAGE_EXTENSIONS, l as Language, X as LanguageConfig, L as LanguageParser, Y as Lead, Z as LeadSchema, _ as LeadSource, $ as LeadSourceSchema, a0 as LeadSubmission, a1 as LeadSubmissionSchema, a2 as Location, M as Metrics, f as ModelContextTier, N as NamingConvention, a9 as ParseError, m as ParseResult, aa as ParseStatistics, P as ProductivityImpact, ab as ReadinessRating, ac as RecommendationPriority, ad as SCORING_PROFILES, ae as SIZE_ADJUSTED_THRESHOLDS, S as ScanOptions, af as ScanResult, ag as ScoringConfig, ah as ScoringProfile, ai as ScoringResult, d as Severity, d as SeverityType, ak as SourceLocation, al as SourceRange, a as SpokeOutput, ap as TOOL_NAME_MAP, k as TechnicalValueChain, j as TechnicalValueChainSummary, g as TokenBudget, T as ToolName, c as ToolOptions, ar as ToolOutput, b as ToolScoringOutput, as as UnifiedReport, at as UnifiedReportSchema, au as calculateOverallScore, av as formatScore, aw as formatToolScore, ax as generateHTML, ay as getProjectSizeTier, az as getRating, aA as getRatingDisplay, aB as getRatingSlug, aC as getRatingWithContext, aD as getRecommendedThreshold, aE as getToolWeight, aF as normalizeToolName, aG as parseWeightString } from './client-WVCAIWdJ.js';
+export { e as AIReadyConfig, o as AIReadyConfigSchema, h as AcceptancePrediction, A as AnalysisResult, q as AnalysisResultSchema, r as AnalysisStatus, s as AnalysisStatusSchema, aL as BaseGraphLink, aM as BaseGraphNode, B as BusinessMetrics, t as COMMON_FINE_TUNING_OPTIONS, u as CONTEXT_TIER_THRESHOLDS, v as CommonASTNode, i as ComprehensionDifficulty, w as Config, C as CostConfig, D as DEFAULT_TOOL_WEIGHTS, n as ExportInfo, x as FRIENDLY_TOOL_NAMES, y as FileContent, G as GLOBAL_INFRA_OPTIONS, z as GLOBAL_SCAN_OPTIONS, H as GraphData, J as GraphEdge, K as GraphIssueSeverity, O as GraphMetadata, Q as GraphNode, I as Issue, R as IssueSchema, U as IssueType, V as IssueTypeSchema, W as LANGUAGE_EXTENSIONS, l as Language, X as LanguageConfig, L as LanguageParser, Y as Lead, Z as LeadSchema, _ as LeadSource, $ as LeadSourceSchema, a0 as LeadSubmission, a1 as LeadSubmissionSchema, a2 as Location, a3 as LocationSchema, M as Metrics, a6 as MetricsSchema, f as ModelContextTier, a7 as ModelTier, a8 as ModelTierSchema, N as NamingConvention, a9 as ParseError, m as ParseResult, aa as ParseStatistics, P as ProductivityImpact, ac as RecommendationPriority, ad as SCORING_PROFILES, ae as SIZE_ADJUSTED_THRESHOLDS, S as ScanOptions, af as ScanResult, ag as ScoringConfig, ah as ScoringProfile, ai as ScoringResult, d as Severity, aj as SeveritySchema, d as SeverityType, ak as SourceLocation, al as SourceRange, a as SpokeOutput, am as SpokeOutputSchema, an as SpokeSummary, ao as SpokeSummarySchema, ap as TOOL_NAME_MAP, k as TechnicalValueChain, j as TechnicalValueChainSummary, g as TokenBudget, T as ToolName, aq as ToolNameSchema, c as ToolOptions, ar as ToolOutput, b as ToolScoringOutput, as as UnifiedReport, at as UnifiedReportSchema, au as calculateOverallScore, av as formatScore, aw as formatToolScore, ax as generateHTML, az as getProjectSizeTier, aA as getRating, aB as getRatingDisplay, aE as getRatingSlug, aF as getRatingWithContext, aG as getRecommendedThreshold, aI as getToolWeight, aJ as normalizeToolName, aK as parseWeightString } from './client-jGuH6TAG.js';
 import 'zod';

package/dist/client.js

@@ -20,29 +20,41 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
+  AIReadyConfigSchema: () => AIReadyConfigSchema,
+  AnalysisResultSchema: () => AnalysisResultSchema,
   AnalysisStatus: () => AnalysisStatus,
+  AnalysisStatusSchema: () => AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS: () => COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS: () => CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS: () => DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES: () => FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS: () => GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS: () => GLOBAL_SCAN_OPTIONS,
+  IssueSchema: () => IssueSchema,
   IssueType: () => IssueType,
+  IssueTypeSchema: () => IssueTypeSchema,
   LANGUAGE_EXTENSIONS: () => LANGUAGE_EXTENSIONS,
   Language: () => Language,
   LeadSchema: () => LeadSchema,
   LeadSource: () => LeadSource,
   LeadSourceSchema: () => LeadSourceSchema,
   LeadSubmissionSchema: () => LeadSubmissionSchema,
+  LocationSchema: () => LocationSchema,
+  MetricsSchema: () => MetricsSchema,
+  ModelTier: () => ModelTier,
+  ModelTierSchema: () => ModelTierSchema,
   ParseError: () => ParseError,
-  ReadinessRating: () => ReadinessRating,
   RecommendationPriority: () => RecommendationPriority,
   SCORING_PROFILES: () => SCORING_PROFILES,
   SIZE_ADJUSTED_THRESHOLDS: () => SIZE_ADJUSTED_THRESHOLDS,
   ScoringProfile: () => ScoringProfile,
   Severity: () => Severity,
+  SeveritySchema: () => SeveritySchema,
+  SpokeOutputSchema: () => SpokeOutputSchema,
+  SpokeSummarySchema: () => SpokeSummarySchema,
   TOOL_NAME_MAP: () => TOOL_NAME_MAP,
   ToolName: () => ToolName,
+  ToolNameSchema: () => ToolNameSchema,
   UnifiedReportSchema: () => UnifiedReportSchema,
   calculateOverallScore: () => calculateOverallScore,
   formatScore: () => formatScore,
@@ -60,8 +72,66 @@ __export(client_exports, {
 });
 module.exports = __toCommonJS(client_exports);
 
-// src/types/schema.ts
+// 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 Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Critical"] = "critical";
   Severity2["Major"] = "major";
@@ -69,7 +139,7 @@ var Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Info"] = "info";
   return Severity2;
 })(Severity || {});
-var SeveritySchema = import_zod.z.nativeEnum(Severity);
+var SeveritySchema = import_zod2.z.nativeEnum(Severity);
 var ToolName = /* @__PURE__ */ ((ToolName2) => {
   ToolName2["PatternDetect"] = "pattern-detect";
   ToolName2["ContextAnalyzer"] = "context-analyzer";
@@ -86,7 +156,7 @@ var ToolName = /* @__PURE__ */ ((ToolName2) => {
   ToolName2["SemanticDistance"] = "semantic-distance";
   return ToolName2;
 })(ToolName || {});
-var ToolNameSchema = import_zod.z.nativeEnum(ToolName);
+var ToolNameSchema = import_zod2.z.nativeEnum(ToolName);
 var FRIENDLY_TOOL_NAMES = {
   ["pattern-detect" /* PatternDetect */]: "Semantic Duplicates",
   ["context-analyzer" /* ContextAnalyzer */]: "Context Fragmentation",
@@ -123,14 +193,14 @@ var IssueType = /* @__PURE__ */ ((IssueType2) => {
   IssueType2["ChangeAmplification"] = "change-amplification";
   return IssueType2;
 })(IssueType || {});
-var IssueTypeSchema = import_zod.z.nativeEnum(IssueType);
+var IssueTypeSchema = import_zod2.z.nativeEnum(IssueType);
 var AnalysisStatus = /* @__PURE__ */ ((AnalysisStatus2) => {
   AnalysisStatus2["Processing"] = "processing";
   AnalysisStatus2["Completed"] = "completed";
   AnalysisStatus2["Failed"] = "failed";
   return AnalysisStatus2;
 })(AnalysisStatus || {});
-var AnalysisStatusSchema = import_zod.z.nativeEnum(AnalysisStatus);
+var AnalysisStatusSchema = import_zod2.z.nativeEnum(AnalysisStatus);
 var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Compact"] = "compact";
   ModelTier2["Standard"] = "standard";
@@ -138,192 +208,149 @@ var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Frontier"] = "frontier";
   return ModelTier2;
 })(ModelTier || {});
-var ModelTierSchema = import_zod.z.nativeEnum(ModelTier);
-var LocationSchema = import_zod.z.object({
-  file: import_zod.z.string(),
-  line: import_zod.z.number(),
-  column: import_zod.z.number().optional(),
-  endLine: import_zod.z.number().optional(),
-  endColumn: import_zod.z.number().optional()
+var ModelTierSchema = import_zod2.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 IssueSchema = import_zod.z.object({
+
+// src/types/schemas/issue.ts
+var import_zod4 = require("zod");
+var IssueSchema = import_zod4.z.object({
   type: IssueTypeSchema,
   severity: SeveritySchema,
-  message: import_zod.z.string(),
+  message: import_zod4.z.string(),
   location: LocationSchema,
-  suggestion: import_zod.z.string().optional()
+  suggestion: import_zod4.z.string().optional()
 });
-var MetricsSchema = import_zod.z.object({
-  tokenCost: import_zod.z.number().optional(),
-  complexityScore: import_zod.z.number().optional(),
-  consistencyScore: import_zod.z.number().optional(),
-  docFreshnessScore: import_zod.z.number().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(),
   // AI agent readiness metrics (v0.12+)
-  aiSignalClarityScore: import_zod.z.number().optional(),
-  agentGroundingScore: import_zod.z.number().optional(),
-  testabilityScore: import_zod.z.number().optional(),
-  docDriftScore: import_zod.z.number().optional(),
-  dependencyHealthScore: import_zod.z.number().optional(),
+  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(),
   modelContextTier: ModelTierSchema.optional(),
   // Business value metrics
-  estimatedMonthlyCost: import_zod.z.number().optional(),
-  estimatedDeveloperHours: import_zod.z.number().optional(),
-  comprehensionDifficultyIndex: import_zod.z.number().optional(),
+  estimatedMonthlyCost: import_zod5.z.number().optional(),
+  estimatedDeveloperHours: import_zod5.z.number().optional(),
+  comprehensionDifficultyIndex: import_zod5.z.number().optional(),
   // Extended metrics for specific spokes
-  totalSymbols: import_zod.z.number().optional(),
-  totalExports: import_zod.z.number().optional()
+  totalSymbols: import_zod5.z.number().optional(),
+  totalExports: import_zod5.z.number().optional()
 });
-var AnalysisResultSchema = import_zod.z.object({
-  fileName: import_zod.z.string(),
-  issues: import_zod.z.array(IssueSchema),
+
+// 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),
   metrics: MetricsSchema
 });
-var SpokeSummarySchema = import_zod.z.object({
-  totalFiles: import_zod.z.number().optional(),
-  totalIssues: import_zod.z.number().optional(),
-  criticalIssues: import_zod.z.number().optional(),
-  majorIssues: import_zod.z.number().optional(),
-  score: import_zod.z.number().optional()
-}).catchall(import_zod.z.any());
-var SpokeOutputSchema = import_zod.z.object({
-  results: import_zod.z.array(AnalysisResultSchema),
+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),
   summary: SpokeSummarySchema,
-  metadata: import_zod.z.object({
-    toolName: import_zod.z.string(),
-    version: import_zod.z.string().optional(),
-    timestamp: import_zod.z.string().optional(),
-    config: import_zod.z.any().optional()
-  }).catchall(import_zod.z.any()).optional()
+  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()
 });
-var UnifiedReportSchema = import_zod.z.object({
-  summary: import_zod.z.object({
-    totalFiles: import_zod.z.number(),
-    totalIssues: import_zod.z.number(),
-    criticalIssues: import_zod.z.number(),
-    majorIssues: import_zod.z.number(),
-    businessImpact: import_zod.z.object({
-      estimatedMonthlyWaste: import_zod.z.number().optional(),
-      potentialSavings: import_zod.z.number().optional(),
-      productivityHours: import_zod.z.number().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()
     }).optional()
   }),
-  results: import_zod.z.array(AnalysisResultSchema),
-  scoring: import_zod.z.object({
-    overall: import_zod.z.number(),
-    rating: import_zod.z.string(),
-    timestamp: import_zod.z.string(),
-    breakdown: import_zod.z.array(
-      import_zod.z.object({
-        toolName: import_zod.z.union([ToolNameSchema, import_zod.z.string()]),
-        score: import_zod.z.number()
-      }).catchall(import_zod.z.any())
+  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())
     )
   }).optional()
-}).catchall(import_zod.z.any());
-var AIReadyConfigSchema = import_zod.z.object({
+}).catchall(import_zod6.z.any());
+
+// src/types/schemas/config.ts
+var import_zod7 = require("zod");
+var AIReadyConfigSchema = import_zod7.z.object({
   /** Target score threshold (0-100) */
-  threshold: import_zod.z.number().optional(),
+  threshold: import_zod7.z.number().optional(),
   /** Files or directories to include in scan */
-  include: import_zod.z.array(import_zod.z.string()).optional(),
+  include: import_zod7.z.array(import_zod7.z.string()).optional(),
   /** Files or directories to exclude from scan */
-  exclude: import_zod.z.array(import_zod.z.string()).optional(),
+  exclude: import_zod7.z.array(import_zod7.z.string()).optional(),
   /** Scan-specific configuration */
-  scan: import_zod.z.object({
-    include: import_zod.z.array(import_zod.z.string()).optional(),
-    exclude: import_zod.z.array(import_zod.z.string()).optional(),
-    parallel: import_zod.z.boolean().optional(),
-    deep: import_zod.z.boolean().optional(),
-    tools: import_zod.z.array(import_zod.z.string()).optional()
+  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()
   }).optional(),
   /** Output-specific configuration */
-  output: import_zod.z.object({
+  output: import_zod7.z.object({
     /** Output format (json, console, html) */
-    format: import_zod.z.enum(["json", "console", "html"]).optional(),
+    format: import_zod7.z.enum(["json", "console", "html"]).optional(),
     /** Output file path */
-    path: import_zod.z.string().optional(),
+    path: import_zod7.z.string().optional(),
     /** Output directory */
-    saveTo: import_zod.z.string().optional(),
+    saveTo: import_zod7.z.string().optional(),
     /** Whether to show score breakdown in console */
-    showBreakdown: import_zod.z.boolean().optional(),
+    showBreakdown: import_zod7.z.boolean().optional(),
     /** Baseline report to compare against */
-    compareBaseline: import_zod.z.string().optional()
+    compareBaseline: import_zod7.z.string().optional()
   }).optional(),
   /** Tool-specific configuration overrides (Strictly ToolName -> Config) */
-  tools: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  tools: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.any()).optional(),
   /** Scoring profile and weights */
-  scoring: import_zod.z.object({
+  scoring: import_zod7.z.object({
     /** Name of the scoring profile (e.g. "strict", "balanced") */
-    profile: import_zod.z.string().optional(),
+    profile: import_zod7.z.string().optional(),
     /** Custom weights for tools and metrics */
-    weights: import_zod.z.record(import_zod.z.string(), import_zod.z.number()).optional()
+    weights: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number()).optional()
   }).optional(),
   /** Visualizer settings (interactive graph) */
-  visualizer: import_zod.z.object({
-    groupingDirs: import_zod.z.array(import_zod.z.string()).optional(),
-    graph: import_zod.z.object({
-      maxNodes: import_zod.z.number().optional(),
-      maxEdges: import_zod.z.number().optional()
+  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()
     }).optional()
   }).optional()
-}).catchall(import_zod.z.any());
-
-// src/types/business.ts
-var import_zod2 = 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_zod2.z.nativeEnum(LeadSource);
-var LeadSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  email: import_zod2.z.string().email(),
-  name: import_zod2.z.string().min(1),
-  interest: import_zod2.z.string().default("General"),
-  notes: import_zod2.z.string().optional(),
-  timestamp: import_zod2.z.string().datetime(),
-  source: LeadSourceSchema,
-  status: import_zod2.z.enum(["new", "contacted", "qualified", "converted", "archived"]).default("new")
-});
-var LeadSubmissionSchema = LeadSchema.omit({
-  id: true,
-  timestamp: true,
-  status: true
-});
-var ManagedAccountSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  // Internal UUID
-  accountId: import_zod2.z.string(),
-  // AWS Account ID
-  userId: import_zod2.z.string(),
-  // Owner (caopengau@gmail.com)
-  stripeSubscriptionId: import_zod2.z.string(),
-  // AI Token Management
-  tokenStrategy: import_zod2.z.enum(["managed", "byok"]).default("managed"),
-  byokConfig: import_zod2.z.object({
-    openaiKey: import_zod2.z.string().optional(),
-    anthropicKey: import_zod2.z.string().optional(),
-    openrouterKey: import_zod2.z.string().optional()
-  }).optional(),
-  // Financials (in cents)
-  baseFeeCents: import_zod2.z.number().default(2900),
-  includedComputeCents: import_zod2.z.number().default(1500),
-  // $15.00 AWS included
-  includedTokenCents: import_zod2.z.number().default(500),
-  // $5.00 Managed Tokens included
-  // Pre-paid Balance (credits)
-  prepaidTokenBalanceCents: import_zod2.z.number().default(0),
-  // Users buy these in $10 packs
-  currentMonthlyTokenSpendCents: import_zod2.z.number().default(0),
-  // Governance
-  status: import_zod2.z.enum(["provisioning", "active", "warning", "quarantined", "suspended"]).default("provisioning"),
-  lastCostSyncAt: import_zod2.z.string().datetime().optional(),
-  region: import_zod2.z.string().default("ap-southeast-2"),
-  // Alerting thresholds (percentage of includedComputeCents)
-  alertThresholds: import_zod2.z.array(import_zod2.z.number()).default([50, 80, 100, 150])
-});
+}).catchall(import_zod7.z.any());
 
 // src/types.ts
 var GLOBAL_INFRA_OPTIONS = [
@@ -382,6 +409,22 @@ var ParseError = class extends Error {
   }
 };
 
+// src/utils/rating-helpers.ts
+function getRatingSlug(score) {
+  if (score >= 90) return "excellent";
+  if (score >= 75) return "good";
+  if (score >= 60) return "fair";
+  if (score >= 40) return "needs-work";
+  return "critical";
+}
+function getRating(score) {
+  if (score >= 90) return "Excellent" /* Excellent */;
+  if (score >= 75) return "Good" /* Good */;
+  if (score >= 60) return "Fair" /* Fair */;
+  if (score >= 40) return "Needs Work" /* NeedsWork */;
+  return "Critical" /* Critical */;
+}
+
 // src/scoring.ts
 var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
   RecommendationPriority2["High"] = "high";
@@ -389,14 +432,6 @@ var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
   RecommendationPriority2["Low"] = "low";
   return RecommendationPriority2;
 })(RecommendationPriority || {});
-var ReadinessRating = /* @__PURE__ */ ((ReadinessRating2) => {
-  ReadinessRating2["Excellent"] = "Excellent";
-  ReadinessRating2["Good"] = "Good";
-  ReadinessRating2["Fair"] = "Fair";
-  ReadinessRating2["NeedsWork"] = "Needs Work";
-  ReadinessRating2["Critical"] = "Critical";
-  return ReadinessRating2;
-})(ReadinessRating || {});
 var DEFAULT_TOOL_WEIGHTS = {
   ["pattern-detect" /* PatternDetect */]: 22,
   ["context-analyzer" /* ContextAnalyzer */]: 19,
@@ -575,20 +610,6 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
     }
   };
 }
-function getRating(score) {
-  if (score >= 90) return "Excellent" /* Excellent */;
-  if (score >= 75) return "Good" /* Good */;
-  if (score >= 60) return "Fair" /* Fair */;
-  if (score >= 40) return "Needs Work" /* NeedsWork */;
-  return "Critical" /* Critical */;
-}
-function getRatingSlug(score) {
-  if (score >= 90) return "excellent";
-  if (score >= 75) return "good";
-  if (score >= 60) return "fair";
-  if (score >= 40) return "needs-work";
-  return "critical";
-}
 function getRatingWithContext(score, fileCount, modelTier = "standard") {
   const threshold = getRecommendedThreshold(fileCount, modelTier);
   const normalized = score - threshold + 70;
@@ -815,29 +836,41 @@ function generateHTML(graph) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AIReadyConfigSchema,
+  AnalysisResultSchema,
   AnalysisStatus,
+  AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  IssueSchema,
   IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
   LeadSchema,
   LeadSource,
   LeadSourceSchema,
   LeadSubmissionSchema,
+  LocationSchema,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
-  ReadinessRating,
   RecommendationPriority,
   SCORING_PROFILES,
   SIZE_ADJUSTED_THRESHOLDS,
   ScoringProfile,
   Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
+  SpokeSummarySchema,
   TOOL_NAME_MAP,
   ToolName,
+  ToolNameSchema,
   UnifiedReportSchema,
   calculateOverallScore,
   formatScore,

package/dist/client.mjs

@@ -1,27 +1,39 @@
 import {
+  AIReadyConfigSchema,
+  AnalysisResultSchema,
   AnalysisStatus,
+  AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  IssueSchema,
   IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
   LeadSchema,
   LeadSource,
   LeadSourceSchema,
   LeadSubmissionSchema,
+  LocationSchema,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
-  ReadinessRating,
   RecommendationPriority,
   SCORING_PROFILES,
   SIZE_ADJUSTED_THRESHOLDS,
   ScoringProfile,
   Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
+  SpokeSummarySchema,
   TOOL_NAME_MAP,
   ToolName,
+  ToolNameSchema,
   UnifiedReportSchema,
   calculateOverallScore,
   formatScore,
@@ -36,31 +48,43 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-CGOS2J6T.mjs";
+} from "./chunk-SQHS6PFL.mjs";
 export {
+  AIReadyConfigSchema,
+  AnalysisResultSchema,
   AnalysisStatus,
+  AnalysisStatusSchema,
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS,
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  IssueSchema,
   IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
   LeadSchema,
   LeadSource,
   LeadSourceSchema,
   LeadSubmissionSchema,
+  LocationSchema,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
-  ReadinessRating,
   RecommendationPriority,
   SCORING_PROFILES,
   SIZE_ADJUSTED_THRESHOLDS,
   ScoringProfile,
   Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
+  SpokeSummarySchema,
   TOOL_NAME_MAP,
   ToolName,
+  ToolNameSchema,
   UnifiedReportSchema,
   calculateOverallScore,
   formatScore,