@aiready/core 0.23.14 → 0.23.19

package/dist/index.js

@@ -176,8 +176,66 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_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";
@@ -185,7 +243,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__ */ ((ToolName3) => {
   ToolName3["PatternDetect"] = "pattern-detect";
   ToolName3["ContextAnalyzer"] = "context-analyzer";
@@ -202,7 +260,7 @@ var ToolName = /* @__PURE__ */ ((ToolName3) => {
   ToolName3["SemanticDistance"] = "semantic-distance";
   return ToolName3;
 })(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",
@@ -239,14 +297,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";
@@ -254,192 +312,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 = [

package/dist/index.mjs

@@ -50,7 +50,7 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-CGOS2J6T.mjs";
+} from "./chunk-RMH2TPAT.mjs";
 
 // src/utils/normalization.ts
 function normalizeIssue(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.23.14",
+  "version": "0.23.19",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",