@aiready/core 0.19.2 → 0.19.5

package/dist/index.js

@@ -30,20 +30,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AnalysisResultSchema: () => AnalysisResultSchema,
+  AnalysisStatus: () => AnalysisStatus,
+  AnalysisStatusSchema: () => AnalysisStatusSchema,
   CONTEXT_TIER_THRESHOLDS: () => CONTEXT_TIER_THRESHOLDS,
   DEFAULT_COST_CONFIG: () => DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE: () => DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS: () => DEFAULT_TOOL_WEIGHTS,
+  FRIENDLY_TOOL_NAMES: () => FRIENDLY_TOOL_NAMES,
+  IssueSchema: () => IssueSchema,
+  IssueType: () => IssueType,
+  IssueTypeSchema: () => IssueTypeSchema,
   LANGUAGE_EXTENSIONS: () => LANGUAGE_EXTENSIONS,
   Language: () => Language,
+  LocationSchema: () => LocationSchema,
   MODEL_PRICING_PRESETS: () => MODEL_PRICING_PRESETS,
+  MetricsSchema: () => MetricsSchema,
+  ModelTier: () => ModelTier,
+  ModelTierSchema: () => ModelTierSchema,
   ParseError: () => ParseError,
   ParserFactory: () => ParserFactory,
   PythonParser: () => PythonParser,
   SEVERITY_TIME_ESTIMATES: () => SEVERITY_TIME_ESTIMATES,
   SIZE_ADJUSTED_THRESHOLDS: () => SIZE_ADJUSTED_THRESHOLDS,
+  Severity: () => Severity,
+  SeveritySchema: () => SeveritySchema,
+  SpokeOutputSchema: () => SpokeOutputSchema,
   TOOL_NAME_MAP: () => TOOL_NAME_MAP,
+  ToolName: () => ToolName,
+  ToolNameSchema: () => ToolNameSchema,
   TypeScriptParser: () => TypeScriptParser,
+  UnifiedReportSchema: () => UnifiedReportSchema,
   VAGUE_FILE_NAMES: () => VAGUE_FILE_NAMES,
   calculateAgentGrounding: () => calculateAgentGrounding,
   calculateAiSignalClarity: () => calculateAiSignalClarity,
@@ -116,10 +133,159 @@ __export(index_exports, {
   saveScoreEntry: () => saveScoreEntry,
   scanEntries: () => scanEntries,
   scanFiles: () => scanFiles,
-  validateSpokeOutput: () => validateSpokeOutput
+  validateSpokeOutput: () => validateSpokeOutput,
+  validateWithSchema: () => validateWithSchema
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/types/schema.ts
+var import_zod = require("zod");
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2["Critical"] = "critical";
+  Severity2["Major"] = "major";
+  Severity2["Minor"] = "minor";
+  Severity2["Info"] = "info";
+  return Severity2;
+})(Severity || {});
+var SeveritySchema = import_zod.z.nativeEnum(Severity);
+var ToolName = /* @__PURE__ */ ((ToolName2) => {
+  ToolName2["PatternDetect"] = "pattern-detect";
+  ToolName2["ContextAnalyzer"] = "context-analyzer";
+  ToolName2["NamingConsistency"] = "naming-consistency";
+  ToolName2["AiSignalClarity"] = "ai-signal-clarity";
+  ToolName2["AgentGrounding"] = "agent-grounding";
+  ToolName2["TestabilityIndex"] = "testability-index";
+  ToolName2["DocDrift"] = "doc-drift";
+  ToolName2["DependencyHealth"] = "dependency-health";
+  ToolName2["ChangeAmplification"] = "change-amplification";
+  ToolName2["CognitiveLoad"] = "cognitive-load";
+  ToolName2["PatternEntropy"] = "pattern-entropy";
+  ToolName2["ConceptCohesion"] = "concept-cohesion";
+  ToolName2["SemanticDistance"] = "semantic-distance";
+  return ToolName2;
+})(ToolName || {});
+var ToolNameSchema = import_zod.z.nativeEnum(ToolName);
+var FRIENDLY_TOOL_NAMES = {
+  ["pattern-detect" /* PatternDetect */]: "Semantic Duplicates",
+  ["context-analyzer" /* ContextAnalyzer */]: "Context Fragmentation",
+  ["naming-consistency" /* NamingConsistency */]: "Naming Consistency",
+  ["ai-signal-clarity" /* AiSignalClarity */]: "AI Signal Clarity",
+  ["agent-grounding" /* AgentGrounding */]: "Agent Grounding",
+  ["testability-index" /* TestabilityIndex */]: "Testability Index",
+  ["doc-drift" /* DocDrift */]: "Documentation Health",
+  ["dependency-health" /* DependencyHealth */]: "Dependency Health",
+  ["change-amplification" /* ChangeAmplification */]: "Change Amplification",
+  ["cognitive-load" /* CognitiveLoad */]: "Cognitive Load",
+  ["pattern-entropy" /* PatternEntropy */]: "Pattern Entropy",
+  ["concept-cohesion" /* ConceptCohesion */]: "Concept Cohesion",
+  ["semantic-distance" /* SemanticDistance */]: "Semantic Distance"
+};
+var IssueType = /* @__PURE__ */ ((IssueType2) => {
+  IssueType2["DuplicatePattern"] = "duplicate-pattern";
+  IssueType2["PatternInconsistency"] = "pattern-inconsistency";
+  IssueType2["ContextFragmentation"] = "context-fragmentation";
+  IssueType2["DependencyHealth"] = "dependency-health";
+  IssueType2["CircularDependency"] = "circular-dependency";
+  IssueType2["DocDrift"] = "doc-drift";
+  IssueType2["NamingInconsistency"] = "naming-inconsistency";
+  IssueType2["NamingQuality"] = "naming-quality";
+  IssueType2["ArchitectureInconsistency"] = "architecture-inconsistency";
+  IssueType2["DeadCode"] = "dead-code";
+  IssueType2["MissingTypes"] = "missing-types";
+  IssueType2["MagicLiteral"] = "magic-literal";
+  IssueType2["BooleanTrap"] = "boolean-trap";
+  IssueType2["AiSignalClarity"] = "ai-signal-clarity";
+  IssueType2["LowTestability"] = "low-testability";
+  IssueType2["AgentNavigationFailure"] = "agent-navigation-failure";
+  IssueType2["AmbiguousApi"] = "ambiguous-api";
+  IssueType2["ChangeAmplification"] = "change-amplification";
+  return IssueType2;
+})(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_zod.z.nativeEnum(AnalysisStatus);
+var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
+  ModelTier2["Compact"] = "compact";
+  ModelTier2["Standard"] = "standard";
+  ModelTier2["Extended"] = "extended";
+  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 IssueSchema = import_zod.z.object({
+  type: IssueTypeSchema,
+  severity: SeveritySchema,
+  message: import_zod.z.string(),
+  location: LocationSchema,
+  suggestion: import_zod.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(),
+  // 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(),
+  modelContextTier: ModelTierSchema.optional(),
+  // Business value metrics
+  estimatedMonthlyCost: import_zod.z.number().optional(),
+  estimatedDeveloperHours: import_zod.z.number().optional(),
+  comprehensionDifficultyIndex: import_zod.z.number().optional(),
+  // Extended metrics for specific spokes
+  totalSymbols: import_zod.z.number().optional(),
+  totalExports: import_zod.z.number().optional()
+});
+var AnalysisResultSchema = import_zod.z.object({
+  fileName: import_zod.z.string(),
+  issues: import_zod.z.array(IssueSchema),
+  metrics: MetricsSchema
+});
+var SpokeOutputSchema = import_zod.z.object({
+  results: import_zod.z.array(AnalysisResultSchema),
+  summary: import_zod.z.any(),
+  metadata: import_zod.z.object({
+    toolName: import_zod.z.string(),
+    version: import_zod.z.string(),
+    timestamp: import_zod.z.string()
+  }).catchall(import_zod.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()
+  }),
+  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())
+    )
+  }).optional()
+}).catchall(import_zod.z.any());
+
 // src/types/language.ts
 var Language = /* @__PURE__ */ ((Language2) => {
   Language2["TypeScript"] = "typescript";
@@ -198,6 +364,16 @@ function validateSpokeOutput(toolName, output) {
     errors
   };
 }
+function validateWithSchema(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { valid: true, data: result.data };
+  }
+  return {
+    valid: false,
+    errors: result.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`)
+  };
+}
 
 // src/utils/file-scanner.ts
 var import_glob = require("glob");
@@ -896,28 +1072,34 @@ function generateHTML(graph) {
 
 // src/scoring.ts
 var DEFAULT_TOOL_WEIGHTS = {
-  "pattern-detect": 22,
-  "context-analyzer": 19,
-  consistency: 14,
-  "ai-signal-clarity": 11,
-  "agent-grounding": 10,
-  testability: 10,
-  "doc-drift": 8,
-  deps: 6
+  ["pattern-detect" /* PatternDetect */]: 22,
+  ["context-analyzer" /* ContextAnalyzer */]: 19,
+  ["naming-consistency" /* NamingConsistency */]: 14,
+  ["ai-signal-clarity" /* AiSignalClarity */]: 11,
+  ["agent-grounding" /* AgentGrounding */]: 10,
+  ["testability-index" /* TestabilityIndex */]: 10,
+  ["doc-drift" /* DocDrift */]: 8,
+  ["dependency-health" /* DependencyHealth */]: 6,
+  ["change-amplification" /* ChangeAmplification */]: 8
 };
 var TOOL_NAME_MAP = {
-  patterns: "pattern-detect",
-  context: "context-analyzer",
-  consistency: "consistency",
-  "AI signal clarity": "ai-signal-clarity",
-  "ai-signal-clarity": "ai-signal-clarity",
-  grounding: "agent-grounding",
-  "agent-grounding": "agent-grounding",
-  testability: "testability",
-  tests: "testability",
-  "doc-drift": "doc-drift",
-  docs: "doc-drift",
-  deps: "deps"
+  patterns: "pattern-detect" /* PatternDetect */,
+  "pattern-detect": "pattern-detect" /* PatternDetect */,
+  context: "context-analyzer" /* ContextAnalyzer */,
+  "context-analyzer": "context-analyzer" /* ContextAnalyzer */,
+  consistency: "naming-consistency" /* NamingConsistency */,
+  "naming-consistency": "naming-consistency" /* NamingConsistency */,
+  "ai-signal": "ai-signal-clarity" /* AiSignalClarity */,
+  "ai-signal-clarity": "ai-signal-clarity" /* AiSignalClarity */,
+  grounding: "agent-grounding" /* AgentGrounding */,
+  "agent-grounding": "agent-grounding" /* AgentGrounding */,
+  testability: "testability-index" /* TestabilityIndex */,
+  "testability-index": "testability-index" /* TestabilityIndex */,
+  "doc-drift": "doc-drift" /* DocDrift */,
+  "deps-health": "dependency-health" /* DependencyHealth */,
+  "dependency-health": "dependency-health" /* DependencyHealth */,
+  "change-amp": "change-amplification" /* ChangeAmplification */,
+  "change-amplification": "change-amplification" /* ChangeAmplification */
 };
 var CONTEXT_TIER_THRESHOLDS = {
   compact: { idealTokens: 3e3, criticalTokens: 1e4, idealDepth: 4 },
@@ -951,22 +1133,16 @@ function getRecommendedThreshold(fileCount, modelTier = "standard") {
   return base + modelBonus;
 }
 function normalizeToolName(shortName) {
-  return TOOL_NAME_MAP[shortName] || shortName;
+  return TOOL_NAME_MAP[shortName.toLowerCase()] || shortName;
 }
 function getToolWeight(toolName, toolConfig, cliOverride) {
-  if (cliOverride !== void 0) {
-    return cliOverride;
-  }
-  if (toolConfig?.scoreWeight !== void 0) {
-    return toolConfig.scoreWeight;
-  }
+  if (cliOverride !== void 0) return cliOverride;
+  if (toolConfig?.scoreWeight !== void 0) return toolConfig.scoreWeight;
   return DEFAULT_TOOL_WEIGHTS[toolName] || 5;
 }
 function parseWeightString(weightStr) {
   const weights = /* @__PURE__ */ new Map();
-  if (!weightStr) {
-    return weights;
-  }
+  if (!weightStr) return weights;
   const pairs = weightStr.split(",");
   for (const pair of pairs) {
     const [toolShortName, weightStr2] = pair.split(":");
@@ -998,8 +1174,7 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
   const calculationWeights = {};
   for (const [toolName, output] of toolOutputs.entries()) {
     const weight = weights.get(toolName) || 5;
-    const weightedScore = output.score * weight;
-    weightedSum += weightedScore;
+    weightedSum += output.score * weight;
     totalWeight += weight;
     toolsUsed.push(toolName);
     calculationWeights[toolName] = weight;
@@ -1218,43 +1393,47 @@ function estimateCostFromBudget(budget, model, config = {}) {
 
 // src/business/productivity-metrics.ts
 var SEVERITY_TIME_ESTIMATES = {
-  critical: 4,
-  major: 2,
-  minor: 0.5,
-  info: 0.25
+  ["critical" /* Critical */]: 4,
+  ["major" /* Major */]: 2,
+  ["minor" /* Minor */]: 0.5,
+  ["info" /* Info */]: 0.25
 };
 var DEFAULT_HOURLY_RATE = 75;
 function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
   const counts = {
-    critical: issues.filter((i) => i.severity === "critical").length,
-    major: issues.filter((i) => i.severity === "major").length,
-    minor: issues.filter((i) => i.severity === "minor").length,
-    info: issues.filter((i) => i.severity === "info").length
+    ["critical" /* Critical */]: issues.filter((i) => i.severity === "critical" /* Critical */).length,
+    ["major" /* Major */]: issues.filter((i) => i.severity === "major" /* Major */).length,
+    ["minor" /* Minor */]: issues.filter((i) => i.severity === "minor" /* Minor */).length,
+    ["info" /* Info */]: issues.filter((i) => i.severity === "info" /* Info */).length
   };
   const hours = {
-    critical: counts.critical * SEVERITY_TIME_ESTIMATES.critical,
-    major: counts.major * SEVERITY_TIME_ESTIMATES.major,
-    minor: counts.minor * SEVERITY_TIME_ESTIMATES.minor,
-    info: counts.info * SEVERITY_TIME_ESTIMATES.info
+    ["critical" /* Critical */]: counts["critical" /* Critical */] * SEVERITY_TIME_ESTIMATES["critical" /* Critical */],
+    ["major" /* Major */]: counts["major" /* Major */] * SEVERITY_TIME_ESTIMATES["major" /* Major */],
+    ["minor" /* Minor */]: counts["minor" /* Minor */] * SEVERITY_TIME_ESTIMATES["minor" /* Minor */],
+    ["info" /* Info */]: counts["info" /* Info */] * SEVERITY_TIME_ESTIMATES["info" /* Info */]
   };
-  const totalHours = hours.critical + hours.major + hours.minor + hours.info;
+  const totalHours = hours["critical" /* Critical */] + hours["major" /* Major */] + hours["minor" /* Minor */] + hours["info" /* Info */];
   const totalCost = totalHours * hourlyRate;
   return {
     totalHours: Math.round(totalHours * 10) / 10,
     hourlyRate,
     totalCost: Math.round(totalCost),
     bySeverity: {
-      critical: {
-        hours: Math.round(hours.critical * 10) / 10,
-        cost: Math.round(hours.critical * hourlyRate)
+      ["critical" /* Critical */]: {
+        hours: Math.round(hours["critical" /* Critical */] * 10) / 10,
+        cost: Math.round(hours["critical" /* Critical */] * hourlyRate)
+      },
+      ["major" /* Major */]: {
+        hours: Math.round(hours["major" /* Major */] * 10) / 10,
+        cost: Math.round(hours["major" /* Major */] * hourlyRate)
       },
-      major: {
-        hours: Math.round(hours.major * 10) / 10,
-        cost: Math.round(hours.major * hourlyRate)
+      ["minor" /* Minor */]: {
+        hours: Math.round(hours["minor" /* Minor */] * 10) / 10,
+        cost: Math.round(hours["minor" /* Minor */] * hourlyRate)
       },
-      minor: {
-        hours: Math.round(hours.minor * 10) / 10,
-        cost: Math.round(hours.minor * hourlyRate)
+      ["info" /* Info */]: {
+        hours: Math.round(hours["info" /* Info */] * 10) / 10,
+        cost: Math.round(hours["info" /* Info */] * hourlyRate)
       }
     }
   };
@@ -2985,20 +3164,37 @@ function getRepoMetadata(directory) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AnalysisResultSchema,
+  AnalysisStatus,
+  AnalysisStatusSchema,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
+  FRIENDLY_TOOL_NAMES,
+  IssueSchema,
+  IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
+  LocationSchema,
   MODEL_PRICING_PRESETS,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
   ParserFactory,
   PythonParser,
   SEVERITY_TIME_ESTIMATES,
   SIZE_ADJUSTED_THRESHOLDS,
+  Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
   TOOL_NAME_MAP,
+  ToolName,
+  ToolNameSchema,
   TypeScriptParser,
+  UnifiedReportSchema,
   VAGUE_FILE_NAMES,
   calculateAgentGrounding,
   calculateAiSignalClarity,
@@ -3071,5 +3267,6 @@ function getRepoMetadata(directory) {
   saveScoreEntry,
   scanEntries,
   scanFiles,
-  validateSpokeOutput
+  validateSpokeOutput,
+  validateWithSchema
 });

package/dist/index.mjs

@@ -1,11 +1,28 @@
 import {
+  AnalysisResultSchema,
+  AnalysisStatus,
+  AnalysisStatusSchema,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_TOOL_WEIGHTS,
+  FRIENDLY_TOOL_NAMES,
+  IssueSchema,
+  IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
+  LocationSchema,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
   SIZE_ADJUSTED_THRESHOLDS,
+  Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
   TOOL_NAME_MAP,
+  ToolName,
+  ToolNameSchema,
+  UnifiedReportSchema,
   calculateOverallScore,
   formatScore,
   formatToolScore,
@@ -18,7 +35,7 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-UQGI67WR.mjs";
+} from "./chunk-QAFB3HXQ.mjs";
 
 // src/types/contract.ts
 function validateSpokeOutput(toolName, output) {
@@ -67,6 +84,16 @@ function validateSpokeOutput(toolName, output) {
     errors
   };
 }
+function validateWithSchema(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { valid: true, data: result.data };
+  }
+  return {
+    valid: false,
+    errors: result.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`)
+  };
+}
 
 // src/utils/file-scanner.ts
 import { glob } from "glob";
@@ -729,43 +756,47 @@ function estimateCostFromBudget(budget, model, config = {}) {
 
 // src/business/productivity-metrics.ts
 var SEVERITY_TIME_ESTIMATES = {
-  critical: 4,
-  major: 2,
-  minor: 0.5,
-  info: 0.25
+  ["critical" /* Critical */]: 4,
+  ["major" /* Major */]: 2,
+  ["minor" /* Minor */]: 0.5,
+  ["info" /* Info */]: 0.25
 };
 var DEFAULT_HOURLY_RATE = 75;
 function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
   const counts = {
-    critical: issues.filter((i) => i.severity === "critical").length,
-    major: issues.filter((i) => i.severity === "major").length,
-    minor: issues.filter((i) => i.severity === "minor").length,
-    info: issues.filter((i) => i.severity === "info").length
+    ["critical" /* Critical */]: issues.filter((i) => i.severity === "critical" /* Critical */).length,
+    ["major" /* Major */]: issues.filter((i) => i.severity === "major" /* Major */).length,
+    ["minor" /* Minor */]: issues.filter((i) => i.severity === "minor" /* Minor */).length,
+    ["info" /* Info */]: issues.filter((i) => i.severity === "info" /* Info */).length
   };
   const hours = {
-    critical: counts.critical * SEVERITY_TIME_ESTIMATES.critical,
-    major: counts.major * SEVERITY_TIME_ESTIMATES.major,
-    minor: counts.minor * SEVERITY_TIME_ESTIMATES.minor,
-    info: counts.info * SEVERITY_TIME_ESTIMATES.info
+    ["critical" /* Critical */]: counts["critical" /* Critical */] * SEVERITY_TIME_ESTIMATES["critical" /* Critical */],
+    ["major" /* Major */]: counts["major" /* Major */] * SEVERITY_TIME_ESTIMATES["major" /* Major */],
+    ["minor" /* Minor */]: counts["minor" /* Minor */] * SEVERITY_TIME_ESTIMATES["minor" /* Minor */],
+    ["info" /* Info */]: counts["info" /* Info */] * SEVERITY_TIME_ESTIMATES["info" /* Info */]
   };
-  const totalHours = hours.critical + hours.major + hours.minor + hours.info;
+  const totalHours = hours["critical" /* Critical */] + hours["major" /* Major */] + hours["minor" /* Minor */] + hours["info" /* Info */];
   const totalCost = totalHours * hourlyRate;
   return {
     totalHours: Math.round(totalHours * 10) / 10,
     hourlyRate,
     totalCost: Math.round(totalCost),
     bySeverity: {
-      critical: {
-        hours: Math.round(hours.critical * 10) / 10,
-        cost: Math.round(hours.critical * hourlyRate)
+      ["critical" /* Critical */]: {
+        hours: Math.round(hours["critical" /* Critical */] * 10) / 10,
+        cost: Math.round(hours["critical" /* Critical */] * hourlyRate)
+      },
+      ["major" /* Major */]: {
+        hours: Math.round(hours["major" /* Major */] * 10) / 10,
+        cost: Math.round(hours["major" /* Major */] * hourlyRate)
       },
-      major: {
-        hours: Math.round(hours.major * 10) / 10,
-        cost: Math.round(hours.major * hourlyRate)
+      ["minor" /* Minor */]: {
+        hours: Math.round(hours["minor" /* Minor */] * 10) / 10,
+        cost: Math.round(hours["minor" /* Minor */] * hourlyRate)
       },
-      minor: {
-        hours: Math.round(hours.minor * 10) / 10,
-        cost: Math.round(hours.minor * hourlyRate)
+      ["info" /* Info */]: {
+        hours: Math.round(hours["info" /* Info */] * 10) / 10,
+        cost: Math.round(hours["info" /* Info */] * hourlyRate)
       }
     }
   };
@@ -2495,20 +2526,37 @@ function getRepoMetadata(directory) {
   return metadata;
 }
 export {
+  AnalysisResultSchema,
+  AnalysisStatus,
+  AnalysisStatusSchema,
   CONTEXT_TIER_THRESHOLDS,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
+  FRIENDLY_TOOL_NAMES,
+  IssueSchema,
+  IssueType,
+  IssueTypeSchema,
   LANGUAGE_EXTENSIONS,
   Language,
+  LocationSchema,
   MODEL_PRICING_PRESETS,
+  MetricsSchema,
+  ModelTier,
+  ModelTierSchema,
   ParseError,
   ParserFactory,
   PythonParser,
   SEVERITY_TIME_ESTIMATES,
   SIZE_ADJUSTED_THRESHOLDS,
+  Severity,
+  SeveritySchema,
+  SpokeOutputSchema,
   TOOL_NAME_MAP,
+  ToolName,
+  ToolNameSchema,
   TypeScriptParser,
+  UnifiedReportSchema,
   VAGUE_FILE_NAMES,
   calculateAgentGrounding,
   calculateAiSignalClarity,
@@ -2581,5 +2629,6 @@ export {
   saveScoreEntry,
   scanEntries,
   scanFiles,
-  validateSpokeOutput
+  validateSpokeOutput,
+  validateWithSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.19.2",
+  "version": "0.19.5",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -48,7 +48,8 @@
     "chalk": "^5.4.1",
     "glob": "^13.0.0",
     "ignore": "^7.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "tsup src/index.ts src/client.ts --format cjs,esm --dts",