@aiready/core 0.23.2 → 0.23.4

package/dist/client.d.mts

@@ -1,1098 +1,2 @@
-import { z } from 'zod';
-
-/**
- * Severity levels for all AIReady issues.
- */
-declare enum Severity {
-    Critical = "critical",
-    Major = "major",
-    Minor = "minor",
-    Info = "info"
-}
-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"
-}
-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"
-}
-declare const IssueTypeSchema: z.ZodEnum<typeof IssueType>;
-/**
- * Analysis processing status.
- */
-declare enum AnalysisStatus {
-    Processing = "processing",
-    Completed = "completed",
-    Failed = "failed"
-}
-declare const AnalysisStatusSchema: z.ZodEnum<typeof AnalysisStatus>;
-/**
- * AI Model Context Tiers.
- */
-declare enum ModelTier {
-    Compact = "compact",
-    Standard = "standard",
-    Extended = "extended",
-    Frontier = "frontier"
-}
-declare const ModelTierSchema: z.ZodEnum<typeof ModelTier>;
-/**
- * Source code location schema.
- */
-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.
- */
-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.
- */
-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>;
-
-/**
- * Cost estimation configuration
- */
-interface CostConfig {
-    /** Price per 1K tokens (default: $0.01 for GPT-4) */
-    pricePer1KTokens: number;
-    /** Average AI queries per developer per day */
-    queriesPerDevPerDay: number;
-    /** Number of developers on the team */
-    developerCount: number;
-    /** Days per month (default: 30) */
-    daysPerMonth: number;
-}
-/**
- * Token budget metrics (v0.13+)
- * Technology-agnostic unit economics for AI impact.
- */
-interface TokenBudget {
-    /** Total tokens required for full task context */
-    totalContextTokens: number;
-    /** Estimated tokens generated in response */
-    estimatedResponseTokens: number;
-    /** Tokens wasted on redundant/duplicated context */
-    wastedTokens: {
-        total: number;
-        bySource: {
-            duplication: number;
-            fragmentation: number;
-            chattiness: number;
-        };
-    };
-    /** Context efficiency ratio (0-1). 1.0 = perfect efficiency. */
-    efficiencyRatio: number;
-    /** Estimated tokens saved if recommendations are followed */
-    potentialRetrievableTokens: number;
-}
-/**
- * Productivity impact estimates
- */
-interface ProductivityImpact {
-    /** Estimated hours to fix all issues */
-    totalHours: number;
-    /** Average hourly rate for developers */
-    hourlyRate: number;
-    /** Estimated total fix cost */
-    totalCost: number;
-    /** Breakdown by severity */
-    bySeverity: {
-        [K in Severity]: {
-            hours: number;
-            cost: number;
-        };
-    };
-}
-/**
- * AI acceptance rate prediction
- * Based on research correlating code quality to AI suggestion acceptance
- */
-interface AcceptancePrediction {
-    /** Predicted acceptance rate (0-1) */
-    rate: number;
-    /** Confidence level (0-1) */
-    confidence: number;
-    /** Factors affecting acceptance */
-    factors: {
-        name: string;
-        impact: number;
-    }[];
-}
-/**
- * Comprehension difficulty score (future-proof abstraction)
- * Normalized 0-100 scale: lower = easier for AI to understand
- */
-interface ComprehensionDifficulty {
-    /** Overall difficulty score (0-100) */
-    score: number;
-    /** Factors contributing to difficulty */
-    factors: {
-        budgetRatio: number;
-        depthRatio: number;
-        fragmentation: number;
-    };
-    /** Interpretation */
-    rating: 'trivial' | 'easy' | 'moderate' | 'difficult' | 'expert';
-}
-/**
- * Technical Value Chain
- * Traces a technical issue through its impact on AI and developer outcomes.
- */
-interface TechnicalValueChain {
-    issueType: string;
-    technicalMetric: string;
-    technicalValue: number;
-    aiImpact: {
-        description: string;
-        scoreImpact: number;
-    };
-    developerImpact: {
-        description: string;
-        productivityLoss: number;
-    };
-    businessOutcome: {
-        directCost: number;
-        opportunityCost: number;
-        riskLevel: 'low' | 'moderate' | 'high' | 'critical';
-    };
-}
-/**
- * v0.13+ simplified technical value chain
- */
-interface TechnicalValueChainSummary {
-    score: number;
-    density: number;
-    complexity: number;
-    surface: number;
-}
-/**
- * Extended report with business metrics
- */
-interface BusinessReport extends Report {
-    businessMetrics: {
-        /** Token-based unit economics (v0.13+) */
-        tokenBudget: TokenBudget;
-        /** @deprecated Use tokenBudget instead. Estimated monthly cost impact of AI context waste */
-        estimatedMonthlyCost: {
-            total: number;
-            range: [number, number];
-            confidence: number;
-        };
-        /** Opportunity cost of project delay due to technical debt */
-        opportunityCost: number;
-        /** Estimated developer hours to address issues */
-        estimatedDeveloperHours: number;
-        /** Predicted AI suggestion acceptance rate */
-        aiAcceptanceRate: number;
-        /** Comprehension difficulty assessment */
-        comprehensionDifficulty: ComprehensionDifficulty;
-        /** Traces for specific critical issues */
-        valueChains?: TechnicalValueChain[];
-        /** Timestamp for trend tracking */
-        period?: string;
-    };
-}
-interface ScanOptions {
-    rootDir: string;
-    include?: string[];
-    exclude?: string[];
-    maxDepth?: number;
-    onProgress?: (processed: number, total: number, message: string) => void;
-    includeTests?: boolean;
-}
-/**
- * Global infrastructure options that apply to the whole scan process.
- * These are passed to all tools but usually omitted from tool-specific audit logs
- * to avoid redundancy.
- */
-declare const GLOBAL_INFRA_OPTIONS: string[];
-/**
- * Common fine-tuning options that might be passed globally but are actually tool-specific.
- */
-declare const COMMON_FINE_TUNING_OPTIONS: string[];
-declare const GLOBAL_SCAN_OPTIONS: string[];
-/**
- * Base configuration for any AIReady tool
- */
-interface BaseToolConfig {
-    /** Whether this tool is enabled for the scan */
-    enabled?: boolean;
-    /** Custom weight for overall score calculation (sum should be 100) */
-    scoreWeight?: number;
-    /** Catch-all for any other tool-specific options */
-    [key: string]: any;
-}
-/**
- * Configuration for the pattern-detect tool (semantic duplicate detection)
- */
-interface PatternDetectConfig extends BaseToolConfig {
-    /** Similarity threshold (0-1). Higher = more strict. */
-    minSimilarity?: number;
-    /** Minimum lines to consider a block */
-    minLines?: number;
-    /** Batch size for parallel processing */
-    batchSize?: number;
-    /** Use approximate matching engine for faster results on large repos */
-    approx?: boolean;
-    /** Minimum tokens shared between blocks for candidates */
-    minSharedTokens?: number;
-    /** Maximum number of candidates to compare per block */
-    maxCandidatesPerBlock?: number;
-}
-/**
- * Configuration for the context-analyzer tool (fragmentation and budget)
- */
-interface ContextAnalyzerConfig extends BaseToolConfig {
-    /** Maximum directory depth to traverse */
-    maxDepth?: number;
-    /** Maximum tokens allowed per context window */
-    maxContextBudget?: number;
-    /** Minimum cohesion score required (0-1) */
-    minCohesion?: number;
-    /** Maximum fragmentation ratio allowed (0-1) */
-    maxFragmentation?: number;
-    /** Primary focus area for the analyzer */
-    focus?: 'fragmentation' | 'cohesion' | 'depth' | 'all';
-    /** Whether to include dependencies from node_modules */
-    includeNodeModules?: boolean;
-    /** Project-specific domain keywords for better inference */
-    domainKeywords?: string[];
-}
-/**
- * Configuration for the naming-consistency tool
- */
-interface NamingConsistencyConfig extends BaseToolConfig {
-    /** Project-approved abbreviations */
-    acceptedAbbreviations?: string[];
-    /** Words that are allowed to be short (like 'id', 'db') */
-    shortWords?: string[];
-    /** Specific checks to disable */
-    disableChecks?: ('single-letter' | 'abbreviation' | 'convention-mix' | 'unclear' | 'poor-naming')[];
-}
-/**
- * Configuration for the ai-signal-clarity tool
- */
-interface AiSignalClarityConfig extends BaseToolConfig {
-    /** Detect unnamed constants */
-    checkMagicLiterals?: boolean;
-    /** Detect positional boolean arguments */
-    checkBooleanTraps?: boolean;
-    /** Detect generic names like 'temp', 'data' */
-    checkAmbiguousNames?: boolean;
-    /** Detect public exports missing JSDoc */
-    checkUndocumentedExports?: boolean;
-    /** Detect implicit state mutations */
-    checkImplicitSideEffects?: boolean;
-    /** Detect deeply nested callbacks */
-    checkDeepCallbacks?: boolean;
-}
-/**
- * Consolidated AIReady configuration schema
- */
-interface AIReadyConfig {
-    /** Global scan settings */
-    scan?: {
-        /** Glob patterns to include */
-        include?: string[];
-        /** Glob patterns to exclude */
-        exclude?: string[];
-        /** List of tools to execute */
-        tools?: string[];
-    };
-    /** Tool-specific configurations */
-    tools?: {
-        'pattern-detect'?: PatternDetectConfig;
-        'context-analyzer'?: ContextAnalyzerConfig;
-        [ToolName.NamingConsistency]?: NamingConsistencyConfig;
-        [ToolName.AiSignalClarity]?: AiSignalClarityConfig;
-        [ToolName.AgentGrounding]?: BaseToolConfig & {
-            maxRecommendedDepth?: number;
-            readmeStaleDays?: number;
-        };
-        [ToolName.TestabilityIndex]?: BaseToolConfig & {
-            minCoverageRatio?: number;
-            testPatterns?: string[];
-        };
-        [ToolName.DocDrift]?: BaseToolConfig & {
-            maxCommits?: number;
-            staleMonths?: number;
-        };
-        [ToolName.DependencyHealth]?: BaseToolConfig & {
-            trainingCutoffYear?: number;
-        };
-        [ToolName.ChangeAmplification]?: BaseToolConfig;
-        /** Support for custom/third-party tools */
-        [toolName: string]: BaseToolConfig | undefined;
-    };
-    /** Global scoring and threshold settings */
-    scoring?: {
-        /** Minimum overall score required to pass CI/CD */
-        threshold?: number;
-        /** Detailed breakdown in terminal output */
-        showBreakdown?: boolean;
-        /** Comparison with a previous run */
-        compareBaseline?: string;
-        /** Auto-persist result to this path */
-        saveTo?: string;
-    };
-    /** Console and file output preferences */
-    output?: {
-        /** Output format (console, json, html) */
-        format?: 'console' | 'json' | 'html';
-        /** Target file for the full report */
-        file?: string;
-    };
-    /** Graph Visualizer preferences */
-    visualizer?: {
-        /** Custom directory grouping levels */
-        groupingDirs?: string[];
-        /** Performance constraints for large graphs */
-        graph?: {
-            maxNodes?: number;
-            maxEdges?: number;
-        };
-    };
-}
-interface Report {
-    summary: {
-        totalFiles: number;
-        totalIssues: number;
-        criticalIssues: number;
-        majorIssues: number;
-    };
-    results: AnalysisResult[];
-    metrics: {
-        overallScore: number;
-        tokenCostTotal: number;
-        avgConsistency: number;
-        executionTime?: number;
-    };
-}
-/**
- * Severity levels for issues
- */
-type GraphIssueSeverity = Severity;
-/**
- * Base graph node
- */
-interface GraphNode {
-    id: string;
-    label: string;
-    path?: string;
-    size?: number;
-    value?: number;
-    color?: string;
-    group?: string;
-    x?: number;
-    y?: number;
-}
-/**
- * Graph edge between nodes
- */
-interface GraphEdge {
-    source: string | GraphNode;
-    target: string | GraphNode;
-    type?: string;
-    weight?: number;
-}
-/**
- * Graph metadata
- */
-interface GraphMetadata {
-    projectName?: string;
-    timestamp: string;
-    totalFiles: number;
-    totalDependencies: number;
-    analysisTypes: string[];
-    criticalIssues: number;
-    majorIssues: number;
-    minorIssues: number;
-    infoIssues: number;
-    /** AI token budget unit economics (v0.13+) */
-    tokenBudget?: TokenBudget;
-    /** Execution time in milliseconds */
-    executionTime?: number;
-}
-/**
- * Complete graph data structure for visualization
- */
-interface GraphData {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-    clusters?: {
-        id: string;
-        name: string;
-        nodeIds: string[];
-    }[];
-    issues?: {
-        id: string;
-        type: string;
-        severity: Severity;
-        nodeIds: string[];
-        message: string;
-    }[];
-    metadata: GraphMetadata;
-}
-
-/**
- * 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>;
-/**
- * Location information in source code
- */
-interface SourceLocation {
-    line: number;
-    column: number;
-}
-interface SourceRange {
-    start: SourceLocation;
-    end: SourceLocation;
-}
-/**
- * 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';
-    /** Behavioral metadata for advanced metrics */
-    isPure?: boolean;
-    hasSideEffects?: boolean;
-    /** Associated documentation */
-    documentation?: {
-        content: string;
-        type: 'jsdoc' | 'docstring' | 'comment' | 'xml-doc';
-        isStale?: boolean;
-    };
-}
-/**
- * Import information
- */
-interface ImportInfo {
-    /** 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;
-}
-/**
- * Parse result containing exports and imports
- */
-interface ParseResult {
-    exports: ExportInfo[];
-    imports: ImportInfo[];
-    /** 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;
-}
-
-/**
- * Priority levels for actionable recommendations
- */
-declare enum RecommendationPriority {
-    High = "high",
-    Medium = "medium",
-    Low = "low"
-}
-/**
- * AI Readiness Rating categories
- */
-declare enum ReadinessRating {
-    Excellent = "Excellent",
-    Good = "Good",
-    Fair = "Fair",
-    NeedsWork = "Needs Work",
-    Critical = "Critical"
-}
-/**
- * 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. Weights sum to 100 and read directly as
- * percentage contribution to the overall score.
- * New tools get weight of 5 if not specified.
- */
-declare const DEFAULT_TOOL_WEIGHTS: Record<string, number>;
-/**
- * Tool name normalization map (shorthand -> canonical name)
- */
-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-type-aware weighting.
- */
-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 (lower penalty for magic literals)
-    Cost = "cost",// Focus on token waste (duplication and fragmentation)
-    Security = "security"
-}
-/**
- * Project-type-aware tool weight presets.
- */
-declare const SCORING_PROFILES: Record<ScoringProfile, Record<string, number>>;
-/**
- * Context budget thresholds per tier.
- */
-declare const CONTEXT_TIER_THRESHOLDS: Record<ModelContextTier, {
-    idealTokens: number;
-    criticalTokens: number;
-    idealDepth: number;
-}>;
-/**
- * Project-size-adjusted minimum thresholds.
- */
-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
- *
- * @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 (e.g. "patterns:30,context:10")
- *
- * @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
- *
- * @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 numeric score to rating category
- *
- * @param score The numerical AI readiness score (0-100)
- * @returns The corresponding ReadinessRating category
- */
-declare function getRating(score: number): ReadinessRating;
-/**
- * Convert score to rating with project-size awareness.
- *
- * @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-adjusted ReadinessRating
- */
-declare function getRatingWithContext(score: number, fileCount: number, modelTier?: ModelContextTier): ReadinessRating;
-/**
- * Get rating display properties (emoji and color)
- *
- * @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 score for human-readable console display
- *
- * @param result The consolidated scoring result
- * @returns Formatted string for display
- */
-declare function formatScore(result: ScoringResult): string;
-/**
- * Format individual tool score for detailed console display
- *
- * @param output The scoring output for a single tool
- * @returns Formatted string with factors and recommendations
- */
-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 { type AIReadyConfig, type AcceptancePrediction, type AiSignalClarityConfig, type AnalysisResult, AnalysisResultSchema, AnalysisStatus, AnalysisStatusSchema, type BaseToolConfig, type BusinessReport, COMMON_FINE_TUNING_OPTIONS, CONTEXT_TIER_THRESHOLDS, type CommonASTNode, type ComprehensionDifficulty, type ContextAnalyzerConfig, type CostConfig, DEFAULT_TOOL_WEIGHTS, type ExportInfo, FRIENDLY_TOOL_NAMES, GLOBAL_INFRA_OPTIONS, GLOBAL_SCAN_OPTIONS, type GraphData, type GraphEdge, type GraphIssueSeverity, type GraphMetadata, type GraphNode, type ImportInfo, type Issue, IssueSchema, IssueType, IssueTypeSchema, LANGUAGE_EXTENSIONS, Language, type LanguageConfig, type LanguageParser, type Location, LocationSchema, type Metrics, MetricsSchema, type ModelContextTier, ModelTier, ModelTierSchema, type NamingConsistencyConfig, type NamingConvention, ParseError, type ParseResult, type ParseStatistics, type PatternDetectConfig, type ProductivityImpact, ReadinessRating, RecommendationPriority, type Report, SCORING_PROFILES, SIZE_ADJUSTED_THRESHOLDS, type ScanOptions, type ScoringConfig, ScoringProfile, type ScoringResult, Severity, SeveritySchema, type SourceLocation, type SourceRange, type SpokeOutput, SpokeOutputSchema, type SpokeSummary, SpokeSummarySchema, TOOL_NAME_MAP, type TechnicalValueChain, type TechnicalValueChainSummary, type TokenBudget, ToolName, ToolNameSchema, type ToolScoringOutput, type UnifiedReport, UnifiedReportSchema, calculateOverallScore, formatScore, formatToolScore, generateHTML, getProjectSizeTier, getRating, getRatingDisplay, getRatingWithContext, getRecommendedThreshold, getToolWeight, normalizeToolName, parseWeightString };
+export { e as AIReadyConfig, g as AcceptancePrediction, A as AnalysisResult, o as AnalysisStatus, B as BusinessMetrics, q as COMMON_FINE_TUNING_OPTIONS, r as CONTEXT_TIER_THRESHOLDS, s as CommonASTNode, h as ComprehensionDifficulty, t as Config, C as CostConfig, D as DEFAULT_TOOL_WEIGHTS, l as ExportInfo, u as FRIENDLY_TOOL_NAMES, v as FileContent, G as GLOBAL_INFRA_OPTIONS, w as GLOBAL_SCAN_OPTIONS, x as GraphData, y as GraphEdge, z as GraphIssueSeverity, H as GraphMetadata, J as GraphNode, I as ImportInfo, K as Issue, Q as IssueType, U as LANGUAGE_EXTENSIONS, k as Language, V as LanguageConfig, L as LanguageParser, W as Location, Y as Metrics, M as ModelContextTier, N as NamingConvention, a0 as ParseError, m as ParseResult, a1 as ParseStatistics, P as ProductivityImpact, a2 as ReadinessRating, a3 as RecommendationPriority, a4 as SCORING_PROFILES, a5 as SIZE_ADJUSTED_THRESHOLDS, S as ScanOptions, a6 as ScanResult, a7 as ScoringConfig, a8 as ScoringProfile, a9 as ScoringResult, c as Severity, c as SeverityType, ab as SourceLocation, ac as SourceRange, a as SpokeOutput, ag as TOOL_NAME_MAP, j as TechnicalValueChain, i as TechnicalValueChainSummary, f as TokenBudget, T as ToolName, ai as ToolOptions, aj as ToolOutput, b as ToolScoringOutput, ak as UnifiedReport, al as UnifiedReportSchema, am as calculateOverallScore, an as formatScore, ao as formatToolScore, ap as generateHTML, aq as getProjectSizeTier, ar as getRating, as as getRatingDisplay, at as getRatingSlug, au as getRatingWithContext, av as getRecommendedThreshold, aw as getToolWeight, ax as normalizeToolName, ay as parseWeightString } from './client-D-cn9ydj.mjs';
+import 'zod';