@aiready/core 0.24.23 → 0.24.26

package/dist/index-ClwnZa_Y.d.mts

@@ -0,0 +1,1333 @@
+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;
+    /** Whether to scan only changed files (git-aware) */
+    changedFilesOnly?: 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>;
+    category: z.ZodOptional<z.ZodString>;
+    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>;
+        category: z.ZodOptional<z.ZodString>;
+        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>;
+    minorIssues: 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>;
+            category: z.ZodOptional<z.ZodString>;
+            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>;
+        minorIssues: 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;
+        minorIssues: 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>;
+            category: z.ZodOptional<z.ZodString>;
+            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<{
+    extends: z.ZodOptional<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>>;
+    autoExclude: z.ZodOptional<z.ZodObject<{
+        tests: z.ZodOptional<z.ZodBoolean>;
+        mocks: z.ZodOptional<z.ZodBoolean>;
+        barrels: z.ZodOptional<z.ZodBoolean>;
+        generated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    failOn: z.ZodOptional<z.ZodEnum<{
+        critical: "critical";
+        major: "major";
+        any: "any";
+        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";
+            html: "html";
+            console: "console";
+        }>>;
+        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.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        severityOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<typeof Severity>>>;
+    }, z.core.$catchall<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.
+ * - `compact`: For models with 4k-16k token windows.
+ * - `standard`: For models with 16k-64k token windows.
+ * - `extended`: For models with 64k-200k token windows.
+ * - `frontier`: For state-of-the-art models with 200k+ token windows.
+ */
+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.
+ *
+ * Defines target ("ideal") and failure ("critical") token counts for each model 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 };