@aiready/core 0.24.18 → 0.24.20

package/dist/index-slasaNzr.d.ts

@@ -0,0 +1,1612 @@
+import { z } from 'zod';
+
+/**
+ * Severity levels for all AIReady issues.
+ */
+declare enum Severity {
+  Critical = 'critical',
+  Major = 'major',
+  Minor = 'minor',
+  Info = 'info',
+}
+/** Zod schema for Severity enum */
+declare const SeveritySchema: z.ZodEnum<typeof Severity>;
+/**
+ * Canonical Tool Names (IDs)
+ * Used everywhere as the single source of truth for tool identification.
+ */
+declare enum ToolName {
+  PatternDetect = 'pattern-detect',
+  ContextAnalyzer = 'context-analyzer',
+  NamingConsistency = 'naming-consistency',
+  AiSignalClarity = 'ai-signal-clarity',
+  AgentGrounding = 'agent-grounding',
+  TestabilityIndex = 'testability-index',
+  DocDrift = 'doc-drift',
+  DependencyHealth = 'dependency-health',
+  ChangeAmplification = 'change-amplification',
+  CognitiveLoad = 'cognitive-load',
+  PatternEntropy = 'pattern-entropy',
+  ConceptCohesion = 'concept-cohesion',
+  SemanticDistance = 'semantic-distance',
+  ContractEnforcement = 'contract-enforcement',
+}
+/** Zod schema for ToolName enum */
+declare const ToolNameSchema: z.ZodEnum<typeof ToolName>;
+/**
+ * Friendly labels for UI display
+ */
+declare const FRIENDLY_TOOL_NAMES: Record<ToolName, string>;
+/**
+ * Standardized issue types across all AIReady tools.
+ */
+declare enum IssueType {
+  DuplicatePattern = 'duplicate-pattern',
+  PatternInconsistency = 'pattern-inconsistency',
+  ContextFragmentation = 'context-fragmentation',
+  DependencyHealth = 'dependency-health',
+  CircularDependency = 'circular-dependency',
+  DocDrift = 'doc-drift',
+  NamingInconsistency = 'naming-inconsistency',
+  NamingQuality = 'naming-quality',
+  ArchitectureInconsistency = 'architecture-inconsistency',
+  DeadCode = 'dead-code',
+  MissingTypes = 'missing-types',
+  MagicLiteral = 'magic-literal',
+  BooleanTrap = 'boolean-trap',
+  AiSignalClarity = 'ai-signal-clarity',
+  LowTestability = 'low-testability',
+  AgentNavigationFailure = 'agent-navigation-failure',
+  AmbiguousApi = 'ambiguous-api',
+  ChangeAmplification = 'change-amplification',
+  ContractGap = 'contract-gap',
+}
+/** Zod schema for IssueType enum */
+declare const IssueTypeSchema: z.ZodEnum<typeof IssueType>;
+/**
+ * Analysis processing status.
+ */
+declare enum AnalysisStatus {
+  Processing = 'processing',
+  Completed = 'completed',
+  Failed = 'failed',
+}
+/** Zod schema for AnalysisStatus enum */
+declare const AnalysisStatusSchema: z.ZodEnum<typeof AnalysisStatus>;
+/**
+ * AI Model Context Tiers.
+ */
+declare enum ModelTier {
+  Compact = 'compact',
+  Standard = 'standard',
+  Extended = 'extended',
+  Frontier = 'frontier',
+}
+/** Zod schema for ModelTier enum */
+declare const ModelTierSchema: z.ZodEnum<typeof ModelTier>;
+
+/**
+ * Common tool options
+ */
+interface ToolOptions {
+  /** Maximum number of results to return */
+  maxResults?: number;
+  /** Severity filter */
+  severity?: 'info' | 'warning' | 'error' | 'critical';
+  /** Output format */
+  outputFormat?: 'json' | 'text' | 'html';
+  /** Additional configuration */
+  config?: Record<string, unknown>;
+  /** Custom key-value pairs */
+  [key: string]: any;
+}
+/**
+ * Source code location schema.
+ */
+/** Zod schema for Location object */
+declare const LocationSchema: z.ZodObject<
+  {
+    file: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    endColumn: z.ZodOptional<z.ZodNumber>;
+  },
+  z.core.$strip
+>;
+type Location = z.infer<typeof LocationSchema>;
+/**
+ * Scan options for tool providers
+ */
+interface ScanOptions extends ToolOptions {
+  /** Target output format */
+  output?:
+    | string
+    | {
+        format: string;
+        file?: string;
+      };
+  /** Visual format (json/console/html) */
+  format?: 'json' | 'console' | 'html';
+  /** Whether to run in parallel */
+  parallel?: boolean;
+}
+
+/**
+ * Standard Issue schema used across all tools.
+ */
+/** Zod schema for Issue object */
+declare const IssueSchema: z.ZodObject<
+  {
+    type: z.ZodEnum<typeof IssueType>;
+    severity: z.ZodEnum<typeof Severity>;
+    message: z.ZodString;
+    location: z.ZodObject<
+      {
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+      },
+      z.core.$strip
+    >;
+    suggestion: z.ZodOptional<z.ZodString>;
+  },
+  z.core.$strip
+>;
+type Issue = z.infer<typeof IssueSchema>;
+/**
+ * Issue overlay on the graph
+ */
+interface IssueOverlay {
+  id: string;
+  type: string;
+  severity: string;
+  nodeIds: string[];
+  edgeIds?: string[];
+  message: string;
+  details?: string;
+}
+
+/**
+ * Standard Metrics schema.
+ */
+/** Zod schema for Metrics object */
+declare const MetricsSchema: z.ZodObject<
+  {
+    tokenCost: z.ZodOptional<z.ZodNumber>;
+    complexityScore: z.ZodOptional<z.ZodNumber>;
+    consistencyScore: z.ZodOptional<z.ZodNumber>;
+    docFreshnessScore: z.ZodOptional<z.ZodNumber>;
+    aiSignalClarityScore: z.ZodOptional<z.ZodNumber>;
+    agentGroundingScore: z.ZodOptional<z.ZodNumber>;
+    testabilityScore: z.ZodOptional<z.ZodNumber>;
+    docDriftScore: z.ZodOptional<z.ZodNumber>;
+    dependencyHealthScore: z.ZodOptional<z.ZodNumber>;
+    modelContextTier: z.ZodOptional<z.ZodEnum<typeof ModelTier>>;
+    estimatedMonthlyCost: z.ZodOptional<z.ZodNumber>;
+    estimatedDeveloperHours: z.ZodOptional<z.ZodNumber>;
+    comprehensionDifficultyIndex: z.ZodOptional<z.ZodNumber>;
+    totalSymbols: z.ZodOptional<z.ZodNumber>;
+    totalExports: z.ZodOptional<z.ZodNumber>;
+  },
+  z.core.$strip
+>;
+type Metrics = z.infer<typeof MetricsSchema>;
+
+/**
+ * Individual file/module analysis result.
+ */
+declare const AnalysisResultSchema: z.ZodObject<
+  {
+    fileName: z.ZodString;
+    issues: z.ZodArray<
+      z.ZodObject<
+        {
+          type: z.ZodEnum<typeof IssueType>;
+          severity: z.ZodEnum<typeof Severity>;
+          message: z.ZodString;
+          location: z.ZodObject<
+            {
+              file: z.ZodString;
+              line: z.ZodNumber;
+              column: z.ZodOptional<z.ZodNumber>;
+              endLine: z.ZodOptional<z.ZodNumber>;
+              endColumn: z.ZodOptional<z.ZodNumber>;
+            },
+            z.core.$strip
+          >;
+          suggestion: z.ZodOptional<z.ZodString>;
+        },
+        z.core.$strip
+      >
+    >;
+    metrics: z.ZodObject<
+      {
+        tokenCost: z.ZodOptional<z.ZodNumber>;
+        complexityScore: z.ZodOptional<z.ZodNumber>;
+        consistencyScore: z.ZodOptional<z.ZodNumber>;
+        docFreshnessScore: z.ZodOptional<z.ZodNumber>;
+        aiSignalClarityScore: z.ZodOptional<z.ZodNumber>;
+        agentGroundingScore: z.ZodOptional<z.ZodNumber>;
+        testabilityScore: z.ZodOptional<z.ZodNumber>;
+        docDriftScore: z.ZodOptional<z.ZodNumber>;
+        dependencyHealthScore: z.ZodOptional<z.ZodNumber>;
+        modelContextTier: z.ZodOptional<z.ZodEnum<typeof ModelTier>>;
+        estimatedMonthlyCost: z.ZodOptional<z.ZodNumber>;
+        estimatedDeveloperHours: z.ZodOptional<z.ZodNumber>;
+        comprehensionDifficultyIndex: z.ZodOptional<z.ZodNumber>;
+        totalSymbols: z.ZodOptional<z.ZodNumber>;
+        totalExports: z.ZodOptional<z.ZodNumber>;
+      },
+      z.core.$strip
+    >;
+  },
+  z.core.$strip
+>;
+type AnalysisResult = z.infer<typeof AnalysisResultSchema>;
+/**
+ * Standard spoke tool summary schema.
+ */
+declare const SpokeSummarySchema: z.ZodObject<
+  {
+    totalFiles: z.ZodOptional<z.ZodNumber>;
+    totalIssues: z.ZodOptional<z.ZodNumber>;
+    criticalIssues: z.ZodOptional<z.ZodNumber>;
+    majorIssues: z.ZodOptional<z.ZodNumber>;
+    score: z.ZodOptional<z.ZodNumber>;
+  },
+  z.core.$catchall<z.ZodAny>
+>;
+type SpokeSummary = z.infer<typeof SpokeSummarySchema>;
+/**
+ * Standard spoke tool output contract.
+ */
+declare const SpokeOutputSchema: z.ZodObject<
+  {
+    results: z.ZodArray<
+      z.ZodObject<
+        {
+          fileName: z.ZodString;
+          issues: z.ZodArray<
+            z.ZodObject<
+              {
+                type: z.ZodEnum<typeof IssueType>;
+                severity: z.ZodEnum<typeof Severity>;
+                message: z.ZodString;
+                location: z.ZodObject<
+                  {
+                    file: z.ZodString;
+                    line: z.ZodNumber;
+                    column: z.ZodOptional<z.ZodNumber>;
+                    endLine: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
+                  },
+                  z.core.$strip
+                >;
+                suggestion: z.ZodOptional<z.ZodString>;
+              },
+              z.core.$strip
+            >
+          >;
+          metrics: z.ZodObject<
+            {
+              tokenCost: z.ZodOptional<z.ZodNumber>;
+              complexityScore: z.ZodOptional<z.ZodNumber>;
+              consistencyScore: z.ZodOptional<z.ZodNumber>;
+              docFreshnessScore: z.ZodOptional<z.ZodNumber>;
+              aiSignalClarityScore: z.ZodOptional<z.ZodNumber>;
+              agentGroundingScore: z.ZodOptional<z.ZodNumber>;
+              testabilityScore: z.ZodOptional<z.ZodNumber>;
+              docDriftScore: z.ZodOptional<z.ZodNumber>;
+              dependencyHealthScore: z.ZodOptional<z.ZodNumber>;
+              modelContextTier: z.ZodOptional<z.ZodEnum<typeof ModelTier>>;
+              estimatedMonthlyCost: z.ZodOptional<z.ZodNumber>;
+              estimatedDeveloperHours: z.ZodOptional<z.ZodNumber>;
+              comprehensionDifficultyIndex: z.ZodOptional<z.ZodNumber>;
+              totalSymbols: z.ZodOptional<z.ZodNumber>;
+              totalExports: z.ZodOptional<z.ZodNumber>;
+            },
+            z.core.$strip
+          >;
+        },
+        z.core.$strip
+      >
+    >;
+    summary: z.ZodObject<
+      {
+        totalFiles: z.ZodOptional<z.ZodNumber>;
+        totalIssues: z.ZodOptional<z.ZodNumber>;
+        criticalIssues: z.ZodOptional<z.ZodNumber>;
+        majorIssues: z.ZodOptional<z.ZodNumber>;
+        score: z.ZodOptional<z.ZodNumber>;
+      },
+      z.core.$catchall<z.ZodAny>
+    >;
+    metadata: z.ZodOptional<
+      z.ZodObject<
+        {
+          toolName: z.ZodString;
+          version: z.ZodOptional<z.ZodString>;
+          timestamp: z.ZodOptional<z.ZodString>;
+          config: z.ZodOptional<z.ZodAny>;
+        },
+        z.core.$catchall<z.ZodAny>
+      >
+    >;
+  },
+  z.core.$strip
+>;
+type SpokeOutput = z.infer<typeof SpokeOutputSchema>;
+/**
+ * Master Unified Report contract (CLI -> Platform).
+ */
+declare const UnifiedReportSchema: z.ZodObject<
+  {
+    summary: z.ZodObject<
+      {
+        totalFiles: z.ZodNumber;
+        totalIssues: z.ZodNumber;
+        criticalIssues: z.ZodNumber;
+        majorIssues: z.ZodNumber;
+        businessImpact: z.ZodOptional<
+          z.ZodObject<
+            {
+              estimatedMonthlyWaste: z.ZodOptional<z.ZodNumber>;
+              potentialSavings: z.ZodOptional<z.ZodNumber>;
+              productivityHours: z.ZodOptional<z.ZodNumber>;
+            },
+            z.core.$strip
+          >
+        >;
+      },
+      z.core.$strip
+    >;
+    results: z.ZodArray<
+      z.ZodObject<
+        {
+          fileName: z.ZodString;
+          issues: z.ZodArray<
+            z.ZodObject<
+              {
+                type: z.ZodEnum<typeof IssueType>;
+                severity: z.ZodEnum<typeof Severity>;
+                message: z.ZodString;
+                location: z.ZodObject<
+                  {
+                    file: z.ZodString;
+                    line: z.ZodNumber;
+                    column: z.ZodOptional<z.ZodNumber>;
+                    endLine: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
+                  },
+                  z.core.$strip
+                >;
+                suggestion: z.ZodOptional<z.ZodString>;
+              },
+              z.core.$strip
+            >
+          >;
+          metrics: z.ZodObject<
+            {
+              tokenCost: z.ZodOptional<z.ZodNumber>;
+              complexityScore: z.ZodOptional<z.ZodNumber>;
+              consistencyScore: z.ZodOptional<z.ZodNumber>;
+              docFreshnessScore: z.ZodOptional<z.ZodNumber>;
+              aiSignalClarityScore: z.ZodOptional<z.ZodNumber>;
+              agentGroundingScore: z.ZodOptional<z.ZodNumber>;
+              testabilityScore: z.ZodOptional<z.ZodNumber>;
+              docDriftScore: z.ZodOptional<z.ZodNumber>;
+              dependencyHealthScore: z.ZodOptional<z.ZodNumber>;
+              modelContextTier: z.ZodOptional<z.ZodEnum<typeof ModelTier>>;
+              estimatedMonthlyCost: z.ZodOptional<z.ZodNumber>;
+              estimatedDeveloperHours: z.ZodOptional<z.ZodNumber>;
+              comprehensionDifficultyIndex: z.ZodOptional<z.ZodNumber>;
+              totalSymbols: z.ZodOptional<z.ZodNumber>;
+              totalExports: z.ZodOptional<z.ZodNumber>;
+            },
+            z.core.$strip
+          >;
+        },
+        z.core.$strip
+      >
+    >;
+    scoring: z.ZodOptional<
+      z.ZodObject<
+        {
+          overall: z.ZodNumber;
+          rating: z.ZodString;
+          timestamp: z.ZodString;
+          breakdown: z.ZodArray<
+            z.ZodObject<
+              {
+                toolName: z.ZodUnion<
+                  readonly [z.ZodEnum<typeof ToolName>, z.ZodString]
+                >;
+                score: z.ZodNumber;
+              },
+              z.core.$catchall<z.ZodAny>
+            >
+          >;
+        },
+        z.core.$strip
+      >
+    >;
+  },
+  z.core.$catchall<z.ZodAny>
+>;
+type UnifiedReport = z.infer<typeof UnifiedReportSchema>;
+
+/**
+ * Global AIReady Configuration Schema.
+ * Strict definition for aiready.json and related config files.
+ */
+declare const AIReadyConfigSchema: z.ZodObject<
+  {
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    failOn: z.ZodOptional<
+      z.ZodEnum<{
+        any: 'any';
+        critical: 'critical';
+        major: 'major';
+        none: 'none';
+      }>
+    >;
+    scan: z.ZodOptional<
+      z.ZodObject<
+        {
+          include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+          exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+          parallel: z.ZodOptional<z.ZodBoolean>;
+          deep: z.ZodOptional<z.ZodBoolean>;
+          tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        },
+        z.core.$strip
+      >
+    >;
+    output: z.ZodOptional<
+      z.ZodObject<
+        {
+          format: z.ZodOptional<
+            z.ZodEnum<{
+              json: 'json';
+              console: 'console';
+              html: 'html';
+            }>
+          >;
+          path: z.ZodOptional<z.ZodString>;
+          saveTo: z.ZodOptional<z.ZodString>;
+          showBreakdown: z.ZodOptional<z.ZodBoolean>;
+          compareBaseline: z.ZodOptional<z.ZodString>;
+        },
+        z.core.$strip
+      >
+    >;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    scoring: z.ZodOptional<
+      z.ZodObject<
+        {
+          profile: z.ZodOptional<z.ZodString>;
+          weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        },
+        z.core.$strip
+      >
+    >;
+    visualizer: z.ZodOptional<
+      z.ZodObject<
+        {
+          groupingDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+          graph: z.ZodOptional<
+            z.ZodObject<
+              {
+                maxNodes: z.ZodOptional<z.ZodNumber>;
+                maxEdges: z.ZodOptional<z.ZodNumber>;
+              },
+              z.core.$strip
+            >
+          >;
+        },
+        z.core.$strip
+      >
+    >;
+  },
+  z.core.$catchall<z.ZodAny>
+>;
+
+/**
+ * Shared types for graph-based visualizations
+ */
+
+/**
+ * Base graph node compatible with d3-force simulation
+ */
+interface BaseGraphNode {
+  id: string;
+  x?: number;
+  y?: number;
+  vx?: number;
+  vy?: number;
+  fx?: number | null;
+  fy?: number | null;
+}
+/**
+ * Base graph link compatible with d3-force simulation
+ */
+interface BaseGraphLink {
+  source: string | BaseGraphNode;
+  target: string | BaseGraphNode;
+  index?: number;
+}
+/**
+ * Full graph node with all metadata
+ */
+interface GraphNode extends BaseGraphNode {
+  label: string;
+  path?: string;
+  size?: number;
+  value?: number;
+  color?: string;
+  group?: string;
+  title?: string;
+  duplicates?: number;
+  tokenCost?: number;
+  severity?: string;
+}
+interface GraphEdge {
+  source: string;
+  target: string;
+  type?: string;
+  weight?: number;
+}
+interface GraphData {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  clusters?: {
+    id: string;
+    name: string;
+    nodeIds: string[];
+  }[];
+  issues?: IssueOverlay[];
+  metadata?: GraphMetadata$1;
+  /** Whether the graph was truncated due to size limits */
+  truncated?: {
+    nodes: boolean;
+    edges: boolean;
+    nodeCount?: number;
+    edgeCount?: number;
+    nodeLimit?: number;
+    edgeLimit?: number;
+  };
+}
+/**
+ * Metadata about the graph
+ */
+interface GraphMetadata$1 {
+  projectName?: string;
+  timestamp?: string;
+  totalFiles?: number;
+  totalDependencies?: number;
+  analysisTypes?: string[];
+  totalLinesOfCode?: number;
+  totalTokenCost?: number;
+  averageComplexity?: number;
+  criticalIssues?: number;
+  majorIssues?: number;
+  minorIssues?: number;
+  infoIssues?: number;
+  estimatedMonthlyCost?: number;
+  estimatedDeveloperHours?: number;
+  aiAcceptanceRate?: number;
+  aiReadinessScore?: number;
+  /** AI token budget unit economics (v0.13+) */
+  tokenBudget?: any;
+}
+
+/**
+ * Lead Source identifiers.
+ */
+declare enum LeadSource {
+  ClawMoreHero = 'clawmore-hero',
+  ClawMoreWaitlist = 'clawmore-waitlist',
+  ClawMoreBeta = 'clawmore-beta',
+  AiReadyPlatform = 'aiready-platform',
+}
+/** Zod schema for LeadSource enum */
+declare const LeadSourceSchema: z.ZodEnum<typeof LeadSource>;
+/**
+ * Business Lead schema for waitlists and beta signups.
+ */
+declare const LeadSchema: z.ZodObject<
+  {
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodString;
+    interest: z.ZodDefault<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    source: z.ZodEnum<typeof LeadSource>;
+    status: z.ZodDefault<
+      z.ZodEnum<{
+        new: 'new';
+        contacted: 'contacted';
+        qualified: 'qualified';
+        converted: 'converted';
+        archived: 'archived';
+      }>
+    >;
+  },
+  z.core.$strip
+>;
+type Lead = z.infer<typeof LeadSchema>;
+/**
+ * Lead Submission (input from form)
+ */
+declare const LeadSubmissionSchema: z.ZodObject<
+  {
+    source: z.ZodEnum<typeof LeadSource>;
+    email: z.ZodString;
+    name: z.ZodString;
+    interest: z.ZodDefault<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+  },
+  z.core.$strip
+>;
+type LeadSubmission = z.infer<typeof LeadSubmissionSchema>;
+/**
+ * Managed AWS Account metadata for the Account Vending Machine.
+ */
+declare const ManagedAccountSchema: z.ZodObject<
+  {
+    id: z.ZodString;
+    accountId: z.ZodString;
+    userId: z.ZodString;
+    stripeSubscriptionId: z.ZodString;
+    tokenStrategy: z.ZodDefault<
+      z.ZodEnum<{
+        managed: 'managed';
+        byok: 'byok';
+      }>
+    >;
+    byokConfig: z.ZodOptional<
+      z.ZodObject<
+        {
+          openaiKey: z.ZodOptional<z.ZodString>;
+          anthropicKey: z.ZodOptional<z.ZodString>;
+          openrouterKey: z.ZodOptional<z.ZodString>;
+        },
+        z.core.$strip
+      >
+    >;
+    baseFeeCents: z.ZodDefault<z.ZodNumber>;
+    includedComputeCents: z.ZodDefault<z.ZodNumber>;
+    includedTokenCents: z.ZodDefault<z.ZodNumber>;
+    prepaidTokenBalanceCents: z.ZodDefault<z.ZodNumber>;
+    currentMonthlyTokenSpendCents: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<
+      z.ZodEnum<{
+        warning: 'warning';
+        provisioning: 'provisioning';
+        active: 'active';
+        quarantined: 'quarantined';
+        suspended: 'suspended';
+      }>
+    >;
+    lastCostSyncAt: z.ZodOptional<z.ZodString>;
+    region: z.ZodDefault<z.ZodString>;
+    alertThresholds: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+  },
+  z.core.$strip
+>;
+type ManagedAccount = z.infer<typeof ManagedAccountSchema>;
+
+/**
+ * Location information in source code
+ */
+interface SourceLocation {
+  line: number;
+  column: number;
+}
+/**
+ * Range information in source code
+ */
+interface SourceRange {
+  start: SourceLocation;
+  end: SourceLocation;
+}
+type ExportType =
+  | 'function'
+  | 'class'
+  | 'interface'
+  | 'type'
+  | 'const'
+  | 'var'
+  | 'enum'
+  | 'module'
+  | 'unknown';
+interface ExportWithImports {
+  name: string;
+  type: ExportType;
+  source?: string;
+  imports: string[];
+  dependencies: string[];
+  typeReferences: string[];
+  loc?: SourceRange;
+}
+/**
+ * Information about a single import declaration
+ */
+interface FileImport {
+  /** Module being imported from */
+  source: string;
+  /** What's being imported */
+  specifiers: string[];
+  /** Is this a type-only import (TypeScript) */
+  isTypeOnly?: boolean;
+  /** Location in source */
+  loc?: SourceRange;
+}
+interface ASTNode {
+  type: string;
+  loc?: SourceRange;
+}
+/**
+ * AI token budget unit economics (v0.13+)
+ */
+interface TokenBudget {
+  totalContextTokens: number;
+  estimatedResponseTokens?: number;
+  wastedTokens: {
+    total: number;
+    bySource: {
+      duplication: number;
+      fragmentation: number;
+      chattiness: number;
+    };
+  };
+  efficiencyRatio: number;
+  potentialRetrievableTokens: number;
+}
+
+/**
+ * AI readiness configuration
+ */
+type AIReadyConfig = z.infer<typeof AIReadyConfigSchema>;
+/**
+ * Legacy alias for Config
+ */
+type Config = AIReadyConfig;
+/**
+ * Result of a single tool execution
+ */
+interface ToolOutput {
+  /** Unique name/ID of the tool */
+  toolName: ToolName | string;
+  /** Whether the tool ran successfully */
+  success: boolean;
+  /** List of issues found by the tool */
+  issues: IssueType[] | any[];
+  /** Numeric metrics produced by the tool */
+  metrics: Metrics;
+  /** Execution duration in milliseconds */
+  duration?: number;
+}
+/**
+ * Overall scan result
+ */
+interface ScanResult {
+  /** ISO timestamp of the scan */
+  timestamp: string;
+  /** Root directory analyzed */
+  rootDir: string;
+  /** Number of files processed */
+  filesAnalyzed: number;
+  /** Total issues found across all tools */
+  totalIssues: number;
+  /** Breakdown of issue counts by type */
+  issuesByType: Record<string, number>;
+  /** Breakdown of issue counts by severity */
+  issuesBySeverity: Record<Severity | string, number>;
+  /** Final calculated AIReady score (0-100) */
+  score: number;
+  /** Individual tool outputs */
+  tools: ToolOutput[];
+}
+/**
+ * Cost configuration for business impact analysis
+ */
+interface CostConfig {
+  /** Price in USD per 1,000 tokens */
+  pricePer1KTokens: number;
+  /** Average number of AI queries per developer per day */
+  queriesPerDevPerDay: number;
+  /** Total number of developers in the team */
+  developerCount: number;
+  /** Working days per month */
+  daysPerMonth: number;
+}
+/**
+ * Productivity impact metrics
+ */
+interface ProductivityImpact {
+  /** Estimated developer hours wasted on quality issues */
+  totalHours: number;
+  /** Developer hourly rate used for calculation */
+  hourlyRate: number;
+  /** Estimated total monthly cost of productivity loss */
+  totalCost: number;
+  /** Impact breakdown by severity */
+  bySeverity: Record<
+    Severity | string,
+    {
+      /** Hours lost for this severity level */
+      hours: number;
+      /** Cost associated with these hours */
+      cost: number;
+    }
+  >;
+}
+/**
+ * AI suggestion acceptance prediction
+ */
+interface AcceptancePrediction {
+  /** Predicted acceptance rate (0-1) */
+  rate: number;
+  /** Confidence level of the prediction (0-1) */
+  confidence: number;
+  /** Qualitative factors influencing the prediction */
+  factors: Array<{
+    /** Factor name */
+    name: string;
+    /** Impact weight (-100 to 100) */
+    impact: number;
+  }>;
+}
+/**
+ * Technical Value Chain summary
+ */
+interface TechnicalValueChain {
+  /** Overall business value score for the component */
+  score?: number;
+  /** Business logic density (e.g. core vs boilerplate) */
+  density?: number;
+  /** Data access layer complexity */
+  complexity?: number;
+  /** API surface area and exposure */
+  surface?: number;
+  /** Issue type associated with this chain */
+  issueType?: string;
+  /** Name of the leading technical metric */
+  technicalMetric?: string;
+  /** Raw value of the technical metric */
+  technicalValue?: number;
+  /** Impact on AI agents */
+  aiImpact?: {
+    description: string;
+    scoreImpact: number;
+  };
+  /** Impact on developer experience */
+  developerImpact?: {
+    description: string;
+    productivityLoss: number;
+  };
+  /** Predicted business outcome */
+  businessOutcome?: {
+    directCost: number;
+    opportunityCost: number;
+    riskLevel: 'low' | 'moderate' | 'high' | 'critical';
+  };
+}
+/**
+ * Compatibility alias
+ */
+type TechnicalValueChainSummary = TechnicalValueChain;
+/**
+ * Code comprehension difficulty metrics
+ */
+interface ComprehensionDifficulty {
+  /** Overall difficulty score (0-100) */
+  score: number;
+  /** Descriptive rating of difficulty */
+  rating: 'trivial' | 'easy' | 'moderate' | 'difficult' | 'expert';
+  /** Ratios and factors contributing to difficulty */
+  factors: {
+    /** Ratio of file tokens to model context limit */
+    budgetRatio: number;
+    /** Relative depth of dependency tree */
+    depthRatio: number;
+    /** Level of logical fragmentation */
+    fragmentation: number;
+  };
+}
+/**
+ * Business impact metrics (v0.10+)
+ */
+interface BusinessMetrics {
+  /** Predicted monthly cost of technical waste */
+  estimatedMonthlyCost?: number;
+  /** Estimated developer hours lost per month */
+  estimatedDeveloperHours?: number;
+  /** Predicted rate of AI suggestion acceptance */
+  aiAcceptanceRate?: number;
+  /** Overall AI readiness score */
+  aiReadinessScore?: number;
+}
+/**
+ * Canonical file content structure
+ */
+interface FileContent {
+  /** Absolute or relative file path */
+  file: string;
+  /** UTF-8 file content */
+  content: string;
+}
+/**
+ * Constants for tests and configuration stability
+ */
+declare const GLOBAL_INFRA_OPTIONS: string[];
+declare const GLOBAL_SCAN_OPTIONS: string[];
+declare const COMMON_FINE_TUNING_OPTIONS: string[];
+
+/**
+ * Analysis issue mapping to graph
+ */
+type GraphIssueSeverity = Severity;
+/**
+ * Graph metadata
+ */
+interface GraphMetadata {
+  /** Project name if available */
+  projectName?: string;
+  /** ISO timestamp of analysis */
+  timestamp: string;
+  /** Total number of files in the graph */
+  totalFiles: number;
+  /** Total dependency edges in the graph */
+  totalDependencies: number;
+  /** Types of analysis performed */
+  analysisTypes: string[];
+  /** Count of critical issues in graph nodes */
+  criticalIssues: number;
+  /** Count of major issues in graph nodes */
+  majorIssues: number;
+  /** Count of minor issues in graph nodes */
+  minorIssues: number;
+  /** Count of informational issues in graph nodes */
+  infoIssues: number;
+  /** AI token budget unit economics (v0.13+) */
+  tokenBudget?: TokenBudget;
+  /** Execution time in milliseconds */
+  executionTime?: number;
+}
+
+/**
+ * Language-agnostic AST and parser interfaces for multi-language support
+ *
+ * This module provides abstractions for parsing different programming languages
+ * while maintaining a consistent interface for analysis tools.
+ */
+
+/**
+ * Supported programming languages
+ */
+declare enum Language {
+  TypeScript = 'typescript',
+  JavaScript = 'javascript',
+  Python = 'python',
+  Java = 'java',
+  Go = 'go',
+  Rust = 'rust',
+  CSharp = 'csharp',
+}
+/**
+ * File extensions mapped to languages
+ */
+declare const LANGUAGE_EXTENSIONS: Record<string, Language>;
+/**
+ * Common AST node type (language-agnostic)
+ */
+interface CommonASTNode {
+  type: string;
+  loc?: SourceRange;
+  raw?: unknown;
+}
+/**
+ * Export information (function, class, variable, etc.)
+ */
+interface ExportInfo {
+  name: string;
+  type:
+    | 'function'
+    | 'class'
+    | 'const'
+    | 'type'
+    | 'interface'
+    | 'default'
+    | 'variable'
+    | 'all';
+  loc?: SourceRange;
+  /** Imports used within this export */
+  imports?: string[];
+  /** Dependencies on other exports in same file */
+  dependencies?: string[];
+  /** TypeScript types referenced */
+  typeReferences?: string[];
+  /** For methods: parent class name */
+  parentClass?: string;
+  /** For functions/methods: parameters */
+  parameters?: string[];
+  /** For classes/interfaces: number of methods and properties */
+  methodCount?: number;
+  propertyCount?: number;
+  /** Visibility (public, private, protected) */
+  visibility?: 'public' | 'private' | 'protected';
+  /** Whether the value is a primitive (string, number, boolean) */
+  isPrimitive?: boolean;
+  /** Behavioral metadata for advanced metrics */
+  isPure?: boolean;
+  hasSideEffects?: boolean;
+  /** Whether the export has explicit type annotations (TS only) */
+  isTyped?: boolean;
+  /** Source file for re-exports (e.g. export { foo } from './bar') */
+  source?: string;
+  /** Inferred domain/area this export belongs to (e.g., "auth", "database") */
+  inferredDomain?: string;
+  /** Associated documentation */
+  documentation?: {
+    content: string;
+    type: 'jsdoc' | 'docstring' | 'comment' | 'xml-doc';
+    loc?: SourceRange;
+    isStale?: boolean;
+  };
+}
+/**
+ * Parse result containing exports and imports
+ */
+interface ParseResult {
+  exports: ExportInfo[];
+  imports: FileImport[];
+  /** Language of the parsed file */
+  language: Language;
+  /** Any parse warnings (non-fatal) */
+  warnings?: string[];
+}
+/**
+ * Naming convention rules per language
+ */
+interface NamingConvention {
+  /** Allowed variable naming patterns */
+  variablePattern: RegExp;
+  /** Allowed function naming patterns */
+  functionPattern: RegExp;
+  /** Allowed class naming patterns */
+  classPattern: RegExp;
+  /** Allowed constant naming patterns */
+  constantPattern: RegExp;
+  /** Allowed type naming patterns */
+  typePattern?: RegExp;
+  /** Allowed interface naming patterns */
+  interfacePattern?: RegExp;
+  /** Language-specific exceptions (e.g., __init__ in Python) */
+  exceptions?: string[];
+}
+/**
+ * Language-specific configuration
+ */
+interface LanguageConfig {
+  language: Language;
+  /** File extensions for this language */
+  extensions: string[];
+  /** Naming conventions */
+  namingConventions: NamingConvention;
+  /** Common abbreviations allowed */
+  allowedAbbreviations?: string[];
+  /** Language-specific keywords to ignore */
+  keywords?: string[];
+}
+/**
+ * Abstract interface for language parsers
+ * Each language implementation should implement this interface
+ */
+interface LanguageParser {
+  /** Language this parser handles */
+  readonly language: Language;
+  /** File extensions this parser supports */
+  readonly extensions: string[];
+  /**
+   * Parse source code and extract structure
+   * @param code - Source code to parse
+   * @param filePath - Path to the file (for context)
+   * @returns Parse result with exports and imports
+   * @throws ParseError if code has syntax errors
+   */
+  parse(code: string, filePath: string): ParseResult;
+  /**
+   * Get naming conventions for this language
+   */
+  getNamingConventions(): NamingConvention;
+  /**
+   * Initialize the parser (e.g. load WASM)
+   */
+  initialize(): Promise<void>;
+  /**
+   * Check if this parser can handle a file
+   * @param filePath - File path to check
+   */
+  canHandle(filePath: string): boolean;
+  /**
+   * Parse the source code into a language-specific AST
+   * @param code - Source code to parse
+   * @param filePath - Path to the file
+   */
+  getAST(code: string, filePath: string): Promise<any>;
+  /**
+   * Analyze structural metadata for a node (e.g. purity)
+   * @param node - The AST node to analyze (language specific)
+   * @param code - The original source code
+   */
+  analyzeMetadata(node: any, code: string): Partial<ExportInfo>;
+}
+/**
+ * Parser error with location information
+ */
+declare class ParseError extends Error {
+  readonly filePath: string;
+  readonly loc?: SourceLocation | undefined;
+  constructor(
+    message: string,
+    filePath: string,
+    loc?: SourceLocation | undefined
+  );
+}
+/**
+ * Statistics about parsed code
+ */
+interface ParseStatistics {
+  language: Language;
+  filesAnalyzed: number;
+  totalExports: number;
+  totalImports: number;
+  parseErrors: number;
+  warnings: number;
+}
+
+/**
+ * Shared rating helper functions for scoring and display.
+ * Extracted to eliminate duplication between scoring.ts and CLI output modules.
+ */
+/**
+ * AI Readiness Rating categories.
+ * Provides a high-level qualitative assessment based on the numeric score.
+ */
+declare enum ReadinessRating {
+  Excellent = 'Excellent',
+  Good = 'Good',
+  Fair = 'Fair',
+  NeedsWork = 'Needs Work',
+  Critical = 'Critical',
+}
+/**
+ * Metadata for a given score range.
+ */
+interface RatingMetadata {
+  label: string;
+  slug: string;
+  emoji: string;
+  rating: ReadinessRating;
+}
+/**
+ * Get all metadata for a specific score.
+ * Unified to remove structural duplication.
+ *
+ * @param score The numerical AI readiness score (0-100)
+ * @returns Metadata object including label, slug, emoji, and rating category
+ */
+declare function getRatingMetadata(score: number): RatingMetadata;
+/**
+ * Get rating label from score
+ * @param score The numerical AI readiness score (0-100)
+ * @returns Human-readable rating label
+ */
+declare function getRatingLabel(score: number): string;
+/**
+ * Get rating slug from score (URL-friendly)
+ * @param score The numerical score
+ * @returns A kebab-case string (e.g., 'excellent', 'needs-work')
+ */
+declare function getRatingSlug(score: number): string;
+/**
+ * Get rating emoji from score
+ * @param score The numerical score
+ * @returns Emoji string for display
+ */
+declare function getRatingEmoji(score: number): string;
+/**
+ * Get tool emoji from score (alias for getRatingEmoji)
+ * @param score The numerical score
+ * @returns Emoji string for display
+ */
+declare function getToolEmoji(score: number): string;
+/**
+ * Get priority icon from priority level
+ * @param priority Priority level string
+ * @returns Emoji string for display
+ */
+declare function getPriorityIcon(priority: string): string;
+/**
+ * Convert numeric score to ReadinessRating enum
+ * @param score The numerical AI readiness score (0-100)
+ * @returns The corresponding ReadinessRating category
+ */
+declare function getRating(score: number): ReadinessRating;
+
+/**
+ * Priority levels for actionable recommendations.
+ * Used to sort and display fixes for the user.
+ */
+declare enum RecommendationPriority {
+  High = 'high',
+  Medium = 'medium',
+  Low = 'low',
+}
+/**
+ * Output structure for a single tool's scoring analysis.
+ */
+interface ToolScoringOutput {
+  /** Unique tool identifier (e.g., "pattern-detect") */
+  toolName: string;
+  /** Normalized 0-100 score for this tool */
+  score: number;
+  /** AI token budget unit economics (v0.13+) */
+  tokenBudget?: any;
+  /** Raw metrics used to calculate the score */
+  rawMetrics: Record<string, any>;
+  /** Factors that influenced the score */
+  factors: Array<{
+    /** Human-readable name of the factor */
+    name: string;
+    /** Points contribution (positive or negative) */
+    impact: number;
+    /** Explanation of the factor's impact */
+    description: string;
+  }>;
+  /** Actionable recommendations with estimated impact */
+  recommendations: Array<{
+    /** The recommended action to take */
+    action: string;
+    /** Potential points increase if implemented */
+    estimatedImpact: number;
+    /** Implementation priority */
+    priority: RecommendationPriority | 'high' | 'medium' | 'low';
+  }>;
+}
+/**
+ * Consolidated scoring result across all tools.
+ */
+interface ScoringResult {
+  /** Overall AI Readiness Score (0-100) */
+  overall: number;
+  /** Rating category representing the overall readiness */
+  rating: string;
+  /** Timestamp of score calculation */
+  timestamp: string;
+  /** Tools that contributed to this score */
+  toolsUsed: string[];
+  /** Breakdown by individual tool */
+  breakdown: ToolScoringOutput[];
+  /** Internal calculation details for transparency */
+  calculation: {
+    /** Textual representation of the calculation formula */
+    formula: string;
+    /** Weights applied to each tool */
+    weights: Record<string, number>;
+    /** Simplified normalized formula output */
+    normalized: string;
+  };
+}
+/**
+ * Configuration options for the scoring system.
+ */
+interface ScoringConfig {
+  /** Minimum passing score (CLI will exit with non-zero if below) */
+  threshold?: number;
+  /** Whether to show the detailed tool-by-tool breakdown */
+  showBreakdown?: boolean;
+  /** Path to a baseline report JSON for trend comparison */
+  compareBaseline?: string;
+  /** Target file path to persist the calculated score */
+  saveTo?: string;
+  /** Scoring profile to use for weighting */
+  profile?: string;
+  /** Tool-specific configurations (e.g., weights) */
+  tools?: Record<
+    string,
+    {
+      scoreWeight?: number;
+    }
+  >;
+}
+
+/**
+ * Default weights for known tools.
+ */
+declare const DEFAULT_TOOL_WEIGHTS: Record<string, number>;
+/**
+ * Tool name normalization map.
+ * Maps common shorthands and aliases to canonical tool IDs.
+ */
+declare const TOOL_NAME_MAP: Record<string, string>;
+/**
+ * Model context tiers for context-aware threshold calibration.
+ */
+type ModelContextTier = 'compact' | 'standard' | 'extended' | 'frontier';
+/**
+ * Scoring profiles for project-aware weighting adjustments.
+ *
+ * Different profiles prioritize different aspects of AI readiness based
+ * on the project's primary focus.
+ */
+declare enum ScoringProfile {
+  Default = 'default',
+  Agentic = 'agentic', // Focus on AI agent navigation and signal
+  Logic = 'logic', // Focus on testability and complexity
+  UI = 'ui', // Focus on consistency and context
+  Cost = 'cost', // Focus on token waste reduction
+  Security = 'security',
+}
+/**
+ * Project-type-aware tool weight presets for different profiles.
+ */
+declare const SCORING_PROFILES: Record<ScoringProfile, Record<string, number>>;
+/**
+ * Context budget thresholds per tier.
+ *
+ * "Ideal" represents target state. "Critical" represents failure state.
+ */
+declare const CONTEXT_TIER_THRESHOLDS: Record<
+  ModelContextTier,
+  {
+    idealTokens: number;
+    criticalTokens: number;
+    idealDepth: number;
+  }
+>;
+/**
+ * Project-size-adjusted minimum thresholds.
+ *
+ * Larger projects have slightly lower thresholds due to inherent complexity.
+ */
+declare const SIZE_ADJUSTED_THRESHOLDS: Record<string, number>;
+/**
+ * Determine project size tier based on the total number of files.
+ *
+ * @param fileCount Total number of files in the project
+ * @returns A string identifier for the project size tier (xs, small, medium, large, enterprise)
+ */
+declare function getProjectSizeTier(
+  fileCount: number
+): keyof typeof SIZE_ADJUSTED_THRESHOLDS;
+/**
+ * Calculate the recommended minimum AI readiness threshold for a project.
+ *
+ * Threshold is adjusted based on project size and the model context tier targeted.
+ *
+ * @param fileCount Total number of files in the project
+ * @param modelTier The model context tier targeted (compact, standard, extended, frontier)
+ * @returns The recommended score threshold (0-100)
+ */
+declare function getRecommendedThreshold(
+  fileCount: number,
+  modelTier?: ModelContextTier
+): number;
+/**
+ * Normalize a tool name from a shorthand or alias to its canonical ID.
+ *
+ * @param shortName The tool shorthand or alias name
+ * @returns The canonical tool ID
+ */
+declare function normalizeToolName(shortName: string): string;
+/**
+ * Retrieve the weight for a specific tool, considering overrides and profiles.
+ *
+ * @param toolName The canonical tool ID
+ * @param toolConfig Optional configuration for the tool containing a weight
+ * @param cliOverride Optional weight override from the CLI
+ * @param profile Optional scoring profile to use
+ * @returns The weight to be used for this tool in overall scoring
+ */
+declare function getToolWeight(
+  toolName: string,
+  toolConfig?: {
+    scoreWeight?: number;
+  },
+  cliOverride?: number,
+  profile?: ScoringProfile
+): number;
+/**
+ * Parse a comma-separated weight string from the CLI.
+ *
+ * Format: "tool1:weight1,tool2:weight2"
+ *
+ * @param weightStr The raw weight string from the CLI or config
+ * @returns A Map of tool IDs to their parsed weights
+ */
+declare function parseWeightString(weightStr?: string): Map<string, number>;
+/**
+ * Calculate the overall consolidated AI Readiness Score.
+ *
+ * Orchestrates the weighted aggregation of all tool individual scores.
+ *
+ * @param toolOutputs Map of tool IDs to their individual scoring outputs
+ * @param config Optional global configuration
+ * @param cliWeights Optional weight overrides from the CLI
+ * @returns Consolidate ScoringResult including overall score and rating
+ */
+declare function calculateOverallScore(
+  toolOutputs: Map<string, ToolScoringOutput>,
+  config?: ScoringConfig,
+  cliWeights?: Map<string, number>
+): ScoringResult;
+/**
+ * Convert score to rating with project-size and model awareness.
+ *
+ * Provides a more accurate rating by considering the target model's limits.
+ *
+ * @param score The numerical AI readiness score
+ * @param fileCount Total number of files in the project
+ * @param modelTier The model context tier being targeted
+ * @returns The size-aware ReadinessRating
+ */
+declare function getRatingWithContext(
+  score: number,
+  fileCount: number,
+  modelTier?: ModelContextTier
+): ReadinessRating;
+/**
+ * Get display properties (emoji and color) for a given rating.
+ *
+ * @param rating The readiness rating category
+ * @returns Object containing display emoji and color string
+ */
+declare function getRatingDisplay(rating: ReadinessRating | string): {
+  emoji: string;
+  color: string;
+};
+/**
+ * Format overall score for compact console display.
+ *
+ * @param result The consolidated scoring result
+ * @returns Formatted string (e.g., "85/100 (Good) 👍")
+ */
+declare function formatScore(result: ScoringResult): string;
+/**
+ * Format detailed tool score for expanded console display.
+ *
+ * Includes breakdown of influencing factors and actionable recommendations.
+ *
+ * @param output The scoring output for a single tool
+ * @returns Multi-line formatted string for console output
+ */
+declare function formatToolScore(output: ToolScoringOutput): string;
+
+/**
+ * Visualization utilities for generating HTML from graph data
+ */
+
+/**
+ * Generate HTML visualization from graph data
+ * Creates an interactive HTML page with a canvas-based graph visualization
+ *
+ * @param graph - The graph data to visualize
+ * @returns HTML string representing the interactive visualization
+ */
+declare function generateHTML(graph: GraphData): string;
+
+export {
+  LeadSource as $,
+  type AnalysisResult as A,
+  type BusinessMetrics as B,
+  type CostConfig as C,
+  DEFAULT_TOOL_WEIGHTS as D,
+  type ExportWithImports as E,
+  type FileImport as F,
+  GLOBAL_INFRA_OPTIONS as G,
+  type GraphData as H,
+  type Issue as I,
+  type GraphEdge as J,
+  type GraphIssueSeverity as K,
+  Language as L,
+  type Metrics as M,
+  type NamingConvention as N,
+  type GraphMetadata as O,
+  type ProductivityImpact as P,
+  type GraphNode as Q,
+  type IssueOverlay as R,
+  type ScanOptions as S,
+  ToolName as T,
+  IssueSchema as U,
+  IssueType as V,
+  IssueTypeSchema as W,
+  LANGUAGE_EXTENSIONS as X,
+  type LanguageConfig as Y,
+  type Lead as Z,
+  LeadSchema as _,
+  type SpokeOutput as a,
+  LeadSourceSchema as a0,
+  type LeadSubmission as a1,
+  LeadSubmissionSchema as a2,
+  type Location as a3,
+  LocationSchema as a4,
+  type ManagedAccount as a5,
+  ManagedAccountSchema as a6,
+  MetricsSchema as a7,
+  ModelTier as a8,
+  ModelTierSchema as a9,
+  getProjectSizeTier as aA,
+  getRating as aB,
+  getRatingDisplay as aC,
+  getRatingEmoji as aD,
+  getRatingLabel as aE,
+  getRatingMetadata as aF,
+  getRatingSlug as aG,
+  getRatingWithContext as aH,
+  getRecommendedThreshold as aI,
+  getToolEmoji as aJ,
+  getToolWeight as aK,
+  normalizeToolName as aL,
+  parseWeightString as aM,
+  type BaseGraphLink as aN,
+  type BaseGraphNode as aO,
+  ParseError as aa,
+  type ParseStatistics as ab,
+  ReadinessRating as ac,
+  RecommendationPriority as ad,
+  SCORING_PROFILES as ae,
+  SIZE_ADJUSTED_THRESHOLDS as af,
+  type ScanResult as ag,
+  type ScoringConfig as ah,
+  ScoringProfile as ai,
+  type ScoringResult as aj,
+  SeveritySchema as ak,
+  type SourceLocation as al,
+  type SourceRange as am,
+  SpokeOutputSchema as an,
+  type SpokeSummary as ao,
+  SpokeSummarySchema as ap,
+  TOOL_NAME_MAP as aq,
+  ToolNameSchema as ar,
+  type ToolOutput as as,
+  type UnifiedReport as at,
+  UnifiedReportSchema as au,
+  calculateOverallScore as av,
+  formatScore as aw,
+  formatToolScore as ax,
+  generateHTML as ay,
+  getPriorityIcon as az,
+  type ToolScoringOutput as b,
+  Severity as c,
+  type ToolOptions as d,
+  type AIReadyConfig as e,
+  type TechnicalValueChain as f,
+  type ModelContextTier as g,
+  type TokenBudget as h,
+  type AcceptancePrediction as i,
+  type ComprehensionDifficulty as j,
+  type TechnicalValueChainSummary as k,
+  type LanguageParser as l,
+  type ParseResult as m,
+  type ExportInfo as n,
+  AIReadyConfigSchema as o,
+  type ASTNode as p,
+  AnalysisResultSchema as q,
+  AnalysisStatus as r,
+  AnalysisStatusSchema as s,
+  COMMON_FINE_TUNING_OPTIONS as t,
+  CONTEXT_TIER_THRESHOLDS as u,
+  type CommonASTNode as v,
+  type Config as w,
+  FRIENDLY_TOOL_NAMES as x,
+  type FileContent as y,
+  GLOBAL_SCAN_OPTIONS as z,
+};