@aiready/core 0.23.20 → 0.23.22

package/dist/client-DGMAxkZc.d.ts

@@ -0,0 +1,1339 @@
+import { z } from 'zod';
+
+/**
+ * AST Parsing and Export Extraction Types
+ */
+/**
+ * Location information in source code
+ */
+interface SourceLocation {
+    line: number;
+    column: number;
+}
+/**
+ * Range information in source code
+ */
+interface SourceRange {
+    start: SourceLocation;
+    end: SourceLocation;
+}
+interface ExportWithImports {
+    name: string;
+    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default' | 'all';
+    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;
+}
+
+/**
+ * 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"
+}
+/** 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"
+}
+/** 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 {
+    /** Root directory of the project */
+    rootDir: string;
+    /** Files to include in this tool's analysis */
+    include?: string[];
+    /** Files to exclude from this tool's analysis */
+    exclude?: string[];
+    /** Tool-specific configuration values */
+    config?: any;
+    /** Any other dynamic options */
+    [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>;
+
+/**
+ * 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>;
+
+/**
+ * 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<{
+    threshold: z.ZodOptional<z.ZodNumber>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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 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?: TokenBudget;
+    /** 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: ReadinessRating | 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;
+}
+/**
+ * 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?: any, 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;
+
+/**
+ * Spoke-to-Hub Contract Definitions
+ * This file defines the expected JSON structure for tool outputs to ensure
+ * changes in spokes don't break the CLI, Platform, or Visualizer.
+ */
+
+/**
+ * Issue overlay on the graph
+ */
+interface IssueOverlay {
+    id: string;
+    type: string;
+    severity: string;
+    nodeIds: string[];
+    edgeIds?: string[];
+    message: string;
+    details?: string;
+}
+/**
+ * Tool Provider Interface
+ * Every AIReady spoke must implement this interface to be integrated into the CLI registry.
+ */
+interface ToolProvider {
+    /** Canonical tool ID */
+    id: ToolName;
+    /** CLI aliases/shorthand for this tool */
+    alias: string[];
+    /** Primary analysis logic */
+    analyze: (options: ScanOptions) => Promise<SpokeOutput>;
+    /** Scoring logic for this tool's output */
+    score: (output: SpokeOutput, options: ScanOptions) => ToolScoringOutput;
+    /** Optional weight override for this tool */
+    defaultWeight?: number;
+}
+/**
+ * Validation utility to ensure a spoke's output matches the expected contract.
+ * Used in spoke tests to catch breakages early.
+ *
+ * @param toolName - Name of the tool being validated.
+ * @param output - The raw output data to check.
+ * @returns Validation result with boolean flag and any errors found.
+ */
+declare function validateSpokeOutput(toolName: string, output: any): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Zod-based validation (Round 1 improvement).
+ *
+ * @param schema - Zod schema to validate against.
+ * @param data - Raw data to parse.
+ * @returns Result object with valid flag and typed data or errors.
+ * @lastUpdated 2026-03-18
+ */
+declare function validateWithSchema<T>(schema: z.ZodSchema<T>, data: any): {
+    valid: boolean;
+    data?: T;
+    errors?: string[];
+};
+
+/**
+ * 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<{
+    name: z.ZodString;
+    source: z.ZodEnum<typeof LeadSource>;
+    email: 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<{
+        provisioning: "provisioning";
+        active: "active";
+        warning: "warning";
+        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>;
+
+/**
+ * AI readiness configuration
+ */
+type AIReadyConfig = z.infer<typeof AIReadyConfigSchema>;
+/**
+ * Legacy alias for Config
+ */
+type Config = AIReadyConfig;
+/**
+ * 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;
+}
+/**
+ * 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?: any;
+}
+/**
+ * Export information (function, class, variable, etc.)
+ */
+interface ExportInfo {
+    name: string;
+    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default' | 'variable';
+    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;
+    /** 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;
+    /**
+     * Get the raw AST for advanced querying
+     * @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;
+}
+
+/**
+ * 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 { LeadSchema 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, GLOBAL_SCAN_OPTIONS as H, type Issue as I, type GraphData as J, type GraphEdge as K, type LanguageParser as L, type Metrics as M, type NamingConvention as N, type GraphIssueSeverity as O, type ProductivityImpact as P, type GraphMetadata as Q, type GraphNode as R, type ScanOptions as S, type ToolProvider as T, type IssueOverlay as U, IssueSchema as V, IssueType as W, IssueTypeSchema as X, LANGUAGE_EXTENSIONS as Y, type LanguageConfig as Z, type Lead as _, ToolName as a, LeadSource as a0, LeadSourceSchema as a1, type LeadSubmission as a2, LeadSubmissionSchema as a3, type Location as a4, LocationSchema as a5, type ManagedAccount as a6, ManagedAccountSchema as a7, MetricsSchema as a8, ModelTier as a9, getPriorityIcon as aA, getProjectSizeTier as aB, getRating as aC, getRatingDisplay as aD, getRatingEmoji as aE, getRatingLabel as aF, getRatingMetadata as aG, getRatingSlug as aH, getRatingWithContext as aI, getRecommendedThreshold as aJ, getToolEmoji as aK, getToolWeight as aL, normalizeToolName as aM, parseWeightString as aN, validateSpokeOutput as aO, validateWithSchema as aP, type BaseGraphLink as aQ, type BaseGraphNode as aR, ModelTierSchema as aa, ParseError as ab, type ParseStatistics as ac, ReadinessRating as ad, RecommendationPriority as ae, SCORING_PROFILES as af, SIZE_ADJUSTED_THRESHOLDS as ag, type ScanResult as ah, type ScoringConfig as ai, ScoringProfile as aj, type ScoringResult as ak, SeveritySchema as al, type SourceLocation as am, type SourceRange as an, SpokeOutputSchema as ao, type SpokeSummary as ap, SpokeSummarySchema as aq, TOOL_NAME_MAP as ar, ToolNameSchema as as, type ToolOutput as at, type UnifiedReport as au, UnifiedReportSchema as av, calculateOverallScore as aw, formatScore as ax, formatToolScore as ay, generateHTML as az, type ToolOptions as b, Severity as c, type ToolScoringOutput as d, type SpokeOutput as e, type AIReadyConfig as f, type ModelContextTier as g, type TokenBudget as h, type AcceptancePrediction as i, type ComprehensionDifficulty as j, type TechnicalValueChainSummary as k, type TechnicalValueChain as l, Language as m, type ParseResult as n, type ExportInfo as o, AIReadyConfigSchema as p, type ASTNode as q, AnalysisResultSchema as r, AnalysisStatus as s, AnalysisStatusSchema as t, COMMON_FINE_TUNING_OPTIONS as u, CONTEXT_TIER_THRESHOLDS as v, type CommonASTNode as w, type Config as x, FRIENDLY_TOOL_NAMES as y, type FileContent as z };