@kb-labs/quality-contracts 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,967 @@
+import { z } from 'zod';
+
+/**
+ * Common types shared across Quality Plugin
+ */
+/**
+ * Package information
+ */
+interface PackageInfo {
+    name: string;
+    version: string;
+    path: string;
+    repository?: string;
+}
+/**
+ * Repository information
+ */
+interface RepositoryInfo {
+    name: string;
+    path: string;
+    packages: PackageInfo[];
+}
+/**
+ * Issue severity levels
+ */
+type IssueSeverity = 'critical' | 'warning' | 'info';
+/**
+ * Generic issue type
+ */
+interface Issue {
+    type: string;
+    severity: IssueSeverity;
+    message: string;
+    package?: string;
+    file?: string;
+    line?: number;
+}
+/**
+ * Recommendation for fixing issues
+ */
+interface Recommendation {
+    title: string;
+    description: string;
+    command?: string;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Build check result
+ */
+interface BuildCheckResult {
+    totalPackages: number;
+    passing: number;
+    failing: number;
+    failures: Array<{
+        package: string;
+        error: string;
+        exitCode: number;
+    }>;
+    staleBuilds: Array<{
+        package: string;
+        distMtime: number;
+        srcMtime: number;
+    }>;
+    duration: number;
+}
+/**
+ * Type analysis result
+ */
+interface TypeAnalysisResult {
+    totalPackages: number;
+    packagesWithErrors: number;
+    totalErrors: number;
+    totalWarnings: number;
+    avgCoverage: number;
+    packages: Array<{
+        name: string;
+        errors: number;
+        warnings: number;
+        coverage: number;
+        anyCount: number;
+        tsIgnoreCount: number;
+    }>;
+    duration: number;
+}
+/**
+ * Test run result
+ */
+interface TestRunResult {
+    totalPackages: number;
+    passing: number;
+    failing: number;
+    skipped: number;
+    failures: Array<{
+        package: string;
+        error: string;
+        exitCode: number;
+        failedTests?: number;
+        totalTests?: number;
+    }>;
+    summary: {
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+    };
+    coverage: {
+        avgCoverage: number;
+        packages: Array<{
+            name: string;
+            lines: number;
+            statements: number;
+            functions: number;
+            branches: number;
+        }>;
+    };
+    duration: number;
+}
+
+/**
+ * Types for quality:stats command
+ */
+
+/**
+ * Health score for a package or repository
+ */
+interface HealthScore {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    issues: Issue[];
+}
+/**
+ * Package statistics
+ */
+interface PackageStats {
+    name: string;
+    path?: string;
+    repository: string;
+    files: number;
+    lines: number;
+    bytes: number;
+}
+/**
+ * Repository statistics
+ */
+interface RepositoryStats {
+    name: string;
+    packages: number;
+    files: number;
+    lines: number;
+    bytes: number;
+}
+/**
+ * Dependency statistics
+ */
+interface DependencyStats {
+    total: number;
+    workspace: number;
+    external: number;
+    duplicates: number;
+    topUsed: Array<{
+        name: string;
+        count: number;
+    }>;
+}
+/**
+ * Statistics result from quality:stats
+ */
+interface StatsResult {
+    overview: {
+        totalPackages: number;
+        totalRepositories: number;
+        totalFiles: number;
+        totalLines: number;
+        totalBytes: number;
+    };
+    byRepository: Record<string, RepositoryStats>;
+    dependencies: DependencyStats;
+    health: HealthScore;
+    largestPackages: PackageStats[];
+}
+
+/**
+ * Constants for Quality Plugin
+ */
+/**
+ * Environment variables
+ */
+declare const QUALITY_ENV_VARS: readonly ["KB_QUALITY_CACHE_TTL", "KB_QUALITY_MAX_PACKAGES"];
+/**
+ * Cache namespace prefix
+ */
+declare const QUALITY_CACHE_PREFIX = "quality:";
+/**
+ * Cache keys
+ */
+declare const CACHE_KEYS: {
+    readonly STATS: "quality:stats";
+    readonly HEALTH: "quality:health";
+    readonly IMPORTS: "quality:imports";
+    readonly EXPORTS: "quality:exports";
+    readonly TYPES: "quality:types";
+    readonly DUPLICATES: "quality:duplicates";
+    readonly BUILDS: "quality:builds";
+    readonly TYPE_ANALYSIS: "quality:type-analysis";
+    readonly TESTS: "quality:tests";
+    readonly DEAD_CODE: "quality:dead-code";
+};
+/**
+ * Default timeouts (milliseconds)
+ */
+declare const DEFAULT_TIMEOUTS: {
+    readonly STATS: 60000;
+    readonly HEALTH: 120000;
+    readonly CHECK_IMPORTS: 60000;
+    readonly CHECK_EXPORTS: 60000;
+    readonly CHECK_TYPES: 90000;
+    readonly TYPES_AUDIT: 180000;
+    readonly FIX_DEPS: 300000;
+    readonly CI: 600000;
+    readonly DEAD_CODE: 120000;
+};
+/**
+ * Health score grades
+ */
+declare const HEALTH_GRADES: {
+    readonly A: {
+        readonly min: 90;
+        readonly max: 100;
+        readonly label: "Excellent";
+    };
+    readonly B: {
+        readonly min: 80;
+        readonly max: 89;
+        readonly label: "Good";
+    };
+    readonly C: {
+        readonly min: 70;
+        readonly max: 79;
+        readonly label: "Fair";
+    };
+    readonly D: {
+        readonly min: 60;
+        readonly max: 69;
+        readonly label: "Poor";
+    };
+    readonly F: {
+        readonly min: 0;
+        readonly max: 59;
+        readonly label: "Failing";
+    };
+};
+
+/**
+ * @module @kb-labs/quality-contracts/routes
+ * REST API route constants for quality plugin
+ */
+/**
+ * REST API base path for quality plugin
+ */
+declare const QUALITY_BASE_PATH: "/v1/plugins/quality";
+/**
+ * REST API route paths (relative to basePath)
+ */
+declare const QUALITY_ROUTES: {
+    /** GET /stats - Get monorepo statistics */
+    readonly STATS: "/stats";
+    /** GET /health - Get health score */
+    readonly HEALTH: "/health";
+    /** GET /dependencies - Get dependency issues */
+    readonly DEPENDENCIES: "/dependencies";
+    /** GET /build-order - Get build order */
+    readonly BUILD_ORDER: "/build-order";
+    /** GET /cycles - Get circular dependencies */
+    readonly CYCLES: "/cycles";
+    /** GET /graph - Get dependency graph */
+    readonly GRAPH: "/graph";
+    /** GET /stale - Get stale packages */
+    readonly STALE: "/stale";
+    /** GET /builds - Get build status */
+    readonly BUILDS: "/builds";
+    /** GET /types - Get type safety analysis */
+    readonly TYPES: "/types";
+    /** GET /tests - Get test results and coverage */
+    readonly TESTS: "/tests";
+};
+/**
+ * Full REST API URLs (basePath + route)
+ * Useful for testing and documentation
+ */
+declare const QUALITY_FULL_ROUTES: {
+    readonly STATS: "/v1/plugins/quality/stats";
+    readonly HEALTH: "/v1/plugins/quality/health";
+    readonly DEPENDENCIES: "/v1/plugins/quality/dependencies";
+    readonly BUILD_ORDER: "/v1/plugins/quality/build-order";
+    readonly CYCLES: "/v1/plugins/quality/cycles";
+    readonly GRAPH: "/v1/plugins/quality/graph";
+    readonly STALE: "/v1/plugins/quality/stale";
+    readonly BUILDS: "/v1/plugins/quality/builds";
+    readonly TYPES: "/v1/plugins/quality/types";
+    readonly TESTS: "/v1/plugins/quality/tests";
+};
+type QualityRoute = typeof QUALITY_ROUTES[keyof typeof QUALITY_ROUTES];
+
+/**
+ * Types for dead code file detection
+ *
+ * Reachability-based analysis: files not reachable from any entry point are dead.
+ */
+/** Why a file is considered alive */
+type AliveReason = 'package-json-entry' | 'tsup-entry' | 'manifest-handler' | 'import-reachable' | 'test-file' | 'config-file' | 'dynamic-import-target';
+/** A file classified as dead (unreachable from any entry point) */
+interface DeadFile {
+    /** Absolute file path */
+    absolutePath: string;
+    /** Path relative to package root */
+    relativePath: string;
+    /** Package name (e.g., @kb-labs/quality-core) */
+    packageName: string;
+    /** Package directory */
+    packageDir: string;
+    /** File size in bytes */
+    sizeBytes: number;
+}
+/** Result for a single package */
+interface PackageDeadCodeResult {
+    packageName: string;
+    packageDir: string;
+    totalFiles: number;
+    aliveFiles: number;
+    deadFiles: DeadFile[];
+    /** Entry points found (shown in --verbose mode) */
+    entryPoints: string[];
+    /** Number of edges in the import graph */
+    graphEdgeCount: number;
+    /** Warnings encountered during analysis */
+    warnings: string[];
+}
+/** Full scan result */
+interface DeadCodeResult {
+    packages: PackageDeadCodeResult[];
+    summary: {
+        totalPackages: number;
+        totalFiles: number;
+        totalAlive: number;
+        totalDead: number;
+        totalDeadBytes: number;
+        emptyDirectories: string[];
+    };
+    duration: number;
+}
+/** Options for scanning */
+interface DeadCodeOptions {
+    /** Filter to specific package name or directory substring */
+    packageFilter?: string;
+    /** If true, include detailed alive reasons in output */
+    verbose?: boolean;
+}
+/** Backup manifest structure */
+interface DeadCodeBackupManifest {
+    id: string;
+    createdAt: string;
+    gitSha: string;
+    gitBranch: string;
+    removedFiles: Array<{
+        originalPath: string;
+        backupPath: string;
+        packageName: string;
+        sizeBytes: number;
+    }>;
+    removedEmptyDirs: string[];
+    cleanedExports: Array<{
+        packageJsonPath: string;
+        removedExportKeys: string[];
+    }>;
+    totalFilesRemoved: number;
+    totalBytesRemoved: number;
+}
+/** Auto-removal result */
+interface DeadCodeRemovalResult {
+    backupId: string;
+    backupPath: string;
+    filesRemoved: number;
+    bytesRemoved: number;
+    emptyDirsRemoved: number;
+    exportsCleanedUp: number;
+    manifest: DeadCodeBackupManifest;
+}
+
+/**
+ * REST API Request/Response Types and Zod Schemas for Quality Plugin
+ */
+
+declare const StatsRequestSchema: z.ZodObject<{
+    includeHealth: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    includeHealth?: boolean | undefined;
+}, {
+    includeHealth?: boolean | undefined;
+}>;
+type StatsRequest = z.infer<typeof StatsRequestSchema>;
+declare const StatsResponseSchema: z.ZodObject<{
+    packages: z.ZodNumber;
+    loc: z.ZodNumber;
+    size: z.ZodString;
+    health: z.ZodOptional<z.ZodNumber>;
+    grade: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    packages: number;
+    loc: number;
+    size: string;
+    health?: number | undefined;
+    grade?: string | undefined;
+}, {
+    packages: number;
+    loc: number;
+    size: string;
+    health?: number | undefined;
+    grade?: string | undefined;
+}>;
+type StatsResponse = z.infer<typeof StatsResponseSchema>;
+declare const HealthRequestSchema: z.ZodObject<{
+    detailed: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    detailed?: boolean | undefined;
+}, {
+    detailed?: boolean | undefined;
+}>;
+type HealthRequest = z.infer<typeof HealthRequestSchema>;
+declare const HealthIssueSchema: z.ZodObject<{
+    type: z.ZodString;
+    severity: z.ZodNumber;
+    description: z.ZodString;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    severity: number;
+    description: string;
+    packages?: string[] | undefined;
+    count?: number | undefined;
+}, {
+    type: string;
+    severity: number;
+    description: string;
+    packages?: string[] | undefined;
+    count?: number | undefined;
+}>;
+type HealthIssue = z.infer<typeof HealthIssueSchema>;
+declare const HealthResponseSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    grade: z.ZodString;
+    issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        severity: z.ZodNumber;
+        description: z.ZodString;
+        packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        severity: number;
+        description: string;
+        packages?: string[] | undefined;
+        count?: number | undefined;
+    }, {
+        type: string;
+        severity: number;
+        description: string;
+        packages?: string[] | undefined;
+        count?: number | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    grade: string;
+    score: number;
+    issues?: {
+        type: string;
+        severity: number;
+        description: string;
+        packages?: string[] | undefined;
+        count?: number | undefined;
+    }[] | undefined;
+}, {
+    grade: string;
+    score: number;
+    issues?: {
+        type: string;
+        severity: number;
+        description: string;
+        packages?: string[] | undefined;
+        count?: number | undefined;
+    }[] | undefined;
+}>;
+type HealthResponse = z.infer<typeof HealthResponseSchema>;
+declare const DependenciesRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type DependenciesRequest = z.infer<typeof DependenciesRequestSchema>;
+declare const VersionInfoSchema: z.ZodObject<{
+    version: z.ZodString;
+    packages: z.ZodArray<z.ZodString, "many">;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    packages: string[];
+    count: number;
+    version: string;
+}, {
+    packages: string[];
+    count: number;
+    version: string;
+}>;
+type VersionInfo = z.infer<typeof VersionInfoSchema>;
+declare const DuplicateDependencySchema: z.ZodObject<{
+    name: z.ZodString;
+    versions: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        packages: z.ZodArray<z.ZodString, "many">;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        packages: string[];
+        count: number;
+        version: string;
+    }, {
+        packages: string[];
+        count: number;
+        version: string;
+    }>, "many">;
+    totalPackages: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    versions: {
+        packages: string[];
+        count: number;
+        version: string;
+    }[];
+    totalPackages: number;
+}, {
+    name: string;
+    versions: {
+        packages: string[];
+        count: number;
+        version: string;
+    }[];
+    totalPackages: number;
+}>;
+type DuplicateDependency = z.infer<typeof DuplicateDependencySchema>;
+declare const UnusedDependencySchema: z.ZodObject<{
+    name: z.ZodString;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    packages: string[];
+    name: string;
+}, {
+    packages: string[];
+    name: string;
+}>;
+type UnusedDependency = z.infer<typeof UnusedDependencySchema>;
+declare const MissingDependencySchema: z.ZodObject<{
+    name: z.ZodString;
+    packages: z.ZodArray<z.ZodString, "many">;
+    importedIn: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    packages: string[];
+    name: string;
+    importedIn: string[];
+}, {
+    packages: string[];
+    name: string;
+    importedIn: string[];
+}>;
+type MissingDependency = z.infer<typeof MissingDependencySchema>;
+declare const DependenciesResponseSchema: z.ZodObject<{
+    duplicates: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        versions: z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            packages: z.ZodArray<z.ZodString, "many">;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            packages: string[];
+            count: number;
+            version: string;
+        }, {
+            packages: string[];
+            count: number;
+            version: string;
+        }>, "many">;
+        totalPackages: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        versions: {
+            packages: string[];
+            count: number;
+            version: string;
+        }[];
+        totalPackages: number;
+    }, {
+        name: string;
+        versions: {
+            packages: string[];
+            count: number;
+            version: string;
+        }[];
+        totalPackages: number;
+    }>, "many">;
+    unused: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        packages: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        packages: string[];
+        name: string;
+    }, {
+        packages: string[];
+        name: string;
+    }>, "many">;
+    missing: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        packages: z.ZodArray<z.ZodString, "many">;
+        importedIn: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        packages: string[];
+        name: string;
+        importedIn: string[];
+    }, {
+        packages: string[];
+        name: string;
+        importedIn: string[];
+    }>, "many">;
+    totalIssues: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    duplicates: {
+        name: string;
+        versions: {
+            packages: string[];
+            count: number;
+            version: string;
+        }[];
+        totalPackages: number;
+    }[];
+    unused: {
+        packages: string[];
+        name: string;
+    }[];
+    missing: {
+        packages: string[];
+        name: string;
+        importedIn: string[];
+    }[];
+    totalIssues: number;
+}, {
+    duplicates: {
+        name: string;
+        versions: {
+            packages: string[];
+            count: number;
+            version: string;
+        }[];
+        totalPackages: number;
+    }[];
+    unused: {
+        packages: string[];
+        name: string;
+    }[];
+    missing: {
+        packages: string[];
+        name: string;
+        importedIn: string[];
+    }[];
+    totalIssues: number;
+}>;
+type DependenciesResponse = z.infer<typeof DependenciesResponseSchema>;
+declare const BuildOrderRequestSchema: z.ZodObject<{
+    packageName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    packageName?: string | undefined;
+}, {
+    packageName?: string | undefined;
+}>;
+type BuildOrderRequest = z.infer<typeof BuildOrderRequestSchema>;
+declare const BuildOrderResponseSchema: z.ZodObject<{
+    layers: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
+    sorted: z.ZodArray<z.ZodString, "many">;
+    circular: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
+    packageCount: z.ZodNumber;
+    layerCount: z.ZodNumber;
+    hasCircular: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    layers: string[][];
+    sorted: string[];
+    circular: string[][];
+    packageCount: number;
+    layerCount: number;
+    hasCircular: boolean;
+}, {
+    layers: string[][];
+    sorted: string[];
+    circular: string[][];
+    packageCount: number;
+    layerCount: number;
+    hasCircular: boolean;
+}>;
+type BuildOrderResponse = z.infer<typeof BuildOrderResponseSchema>;
+declare const CyclesRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type CyclesRequest = z.infer<typeof CyclesRequestSchema>;
+declare const CyclesResponseSchema: z.ZodObject<{
+    cycles: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
+    count: z.ZodNumber;
+    hasCircular: z.ZodBoolean;
+    affected: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    hasCircular: boolean;
+    cycles: string[][];
+    affected: string[];
+}, {
+    count: number;
+    hasCircular: boolean;
+    cycles: string[][];
+    affected: string[];
+}>;
+type CyclesResponse = z.infer<typeof CyclesResponseSchema>;
+declare const GraphModeSchema: z.ZodEnum<["tree", "reverse", "impact", "stats"]>;
+type GraphMode = z.infer<typeof GraphModeSchema>;
+declare const GraphRequestSchema: z.ZodObject<{
+    packageName: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<["tree", "reverse", "impact", "stats"]>;
+}, "strip", z.ZodTypeAny, {
+    mode: "reverse" | "tree" | "impact" | "stats";
+    packageName?: string | undefined;
+}, {
+    mode: "reverse" | "tree" | "impact" | "stats";
+    packageName?: string | undefined;
+}>;
+type GraphRequest = z.infer<typeof GraphRequestSchema>;
+declare const GraphNodeSchema: z.ZodType<GraphNode>;
+type GraphNode = {
+    name: string;
+    children?: GraphNode[];
+};
+declare const GraphStatsSchema: z.ZodObject<{
+    totalPackages: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+    avgDependencies: z.ZodNumber;
+    mostDepended: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        name: string;
+    }, {
+        count: number;
+        name: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    totalPackages: number;
+    maxDepth: number;
+    avgDependencies: number;
+    mostDepended: {
+        count: number;
+        name: string;
+    }[];
+}, {
+    totalPackages: number;
+    maxDepth: number;
+    avgDependencies: number;
+    mostDepended: {
+        count: number;
+        name: string;
+    }[];
+}>;
+type GraphStats = z.infer<typeof GraphStatsSchema>;
+declare const GraphResponseSchema: z.ZodObject<{
+    mode: z.ZodEnum<["tree", "reverse", "impact", "stats"]>;
+    packageName: z.ZodOptional<z.ZodString>;
+    tree: z.ZodOptional<z.ZodType<GraphNode, z.ZodTypeDef, GraphNode>>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    stats: z.ZodOptional<z.ZodObject<{
+        totalPackages: z.ZodNumber;
+        maxDepth: z.ZodNumber;
+        avgDependencies: z.ZodNumber;
+        mostDepended: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            name: string;
+        }, {
+            count: number;
+            name: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        totalPackages: number;
+        maxDepth: number;
+        avgDependencies: number;
+        mostDepended: {
+            count: number;
+            name: string;
+        }[];
+    }, {
+        totalPackages: number;
+        maxDepth: number;
+        avgDependencies: number;
+        mostDepended: {
+            count: number;
+            name: string;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    mode: "reverse" | "tree" | "impact" | "stats";
+    packages?: string[] | undefined;
+    packageName?: string | undefined;
+    tree?: GraphNode | undefined;
+    stats?: {
+        totalPackages: number;
+        maxDepth: number;
+        avgDependencies: number;
+        mostDepended: {
+            count: number;
+            name: string;
+        }[];
+    } | undefined;
+}, {
+    mode: "reverse" | "tree" | "impact" | "stats";
+    packages?: string[] | undefined;
+    packageName?: string | undefined;
+    tree?: GraphNode | undefined;
+    stats?: {
+        totalPackages: number;
+        maxDepth: number;
+        avgDependencies: number;
+        mostDepended: {
+            count: number;
+            name: string;
+        }[];
+    } | undefined;
+}>;
+type GraphResponse = z.infer<typeof GraphResponseSchema>;
+declare const StaleRequestSchema: z.ZodObject<{
+    detailed: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    detailed?: boolean | undefined;
+}, {
+    detailed?: boolean | undefined;
+}>;
+type StaleRequest = z.infer<typeof StaleRequestSchema>;
+declare const StalePackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    reason: z.ZodEnum<["source-newer", "dependency-rebuilt", "missing-dist"]>;
+    sourceModified: z.ZodOptional<z.ZodString>;
+    distModified: z.ZodOptional<z.ZodString>;
+    affectedPackages: z.ZodArray<z.ZodString, "many">;
+    affectedCount: z.ZodNumber;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    name: string;
+    reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+    affectedPackages: string[];
+    affectedCount: number;
+    sourceModified?: string | undefined;
+    distModified?: string | undefined;
+}, {
+    path: string;
+    severity: "critical" | "high" | "medium" | "low";
+    name: string;
+    reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+    affectedPackages: string[];
+    affectedCount: number;
+    sourceModified?: string | undefined;
+    distModified?: string | undefined;
+}>;
+type StalePackage = z.infer<typeof StalePackageSchema>;
+declare const StaleChainSchema: z.ZodObject<{
+    root: z.ZodString;
+    affected: z.ZodArray<z.ZodString, "many">;
+    depth: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    affected: string[];
+    root: string;
+    depth: number;
+}, {
+    affected: string[];
+    root: string;
+    depth: number;
+}>;
+type StaleChain = z.infer<typeof StaleChainSchema>;
+declare const StaleResponseSchema: z.ZodObject<{
+    stalePackages: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        reason: z.ZodEnum<["source-newer", "dependency-rebuilt", "missing-dist"]>;
+        sourceModified: z.ZodOptional<z.ZodString>;
+        distModified: z.ZodOptional<z.ZodString>;
+        affectedPackages: z.ZodArray<z.ZodString, "many">;
+        affectedCount: z.ZodNumber;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        name: string;
+        reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+        affectedPackages: string[];
+        affectedCount: number;
+        sourceModified?: string | undefined;
+        distModified?: string | undefined;
+    }, {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        name: string;
+        reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+        affectedPackages: string[];
+        affectedCount: number;
+        sourceModified?: string | undefined;
+        distModified?: string | undefined;
+    }>, "many">;
+    totalStale: z.ZodNumber;
+    totalAffected: z.ZodNumber;
+    criticalChains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        root: z.ZodString;
+        affected: z.ZodArray<z.ZodString, "many">;
+        depth: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        affected: string[];
+        root: string;
+        depth: number;
+    }, {
+        affected: string[];
+        root: string;
+        depth: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    stalePackages: {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        name: string;
+        reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+        affectedPackages: string[];
+        affectedCount: number;
+        sourceModified?: string | undefined;
+        distModified?: string | undefined;
+    }[];
+    totalStale: number;
+    totalAffected: number;
+    criticalChains?: {
+        affected: string[];
+        root: string;
+        depth: number;
+    }[] | undefined;
+}, {
+    stalePackages: {
+        path: string;
+        severity: "critical" | "high" | "medium" | "low";
+        name: string;
+        reason: "source-newer" | "dependency-rebuilt" | "missing-dist";
+        affectedPackages: string[];
+        affectedCount: number;
+        sourceModified?: string | undefined;
+        distModified?: string | undefined;
+    }[];
+    totalStale: number;
+    totalAffected: number;
+    criticalChains?: {
+        affected: string[];
+        root: string;
+        depth: number;
+    }[] | undefined;
+}>;
+type StaleResponse = z.infer<typeof StaleResponseSchema>;
+
+export { type AliveReason, type BuildCheckResult, type BuildOrderRequest, BuildOrderRequestSchema, type BuildOrderResponse, BuildOrderResponseSchema, CACHE_KEYS, type CyclesRequest, CyclesRequestSchema, type CyclesResponse, CyclesResponseSchema, DEFAULT_TIMEOUTS, type DeadCodeBackupManifest, type DeadCodeOptions, type DeadCodeRemovalResult, type DeadCodeResult, type DeadFile, type DependenciesRequest, DependenciesRequestSchema, type DependenciesResponse, DependenciesResponseSchema, type DependencyStats, type DuplicateDependency, DuplicateDependencySchema, type GraphMode, GraphModeSchema, type GraphNode, GraphNodeSchema, type GraphRequest, GraphRequestSchema, type GraphResponse, GraphResponseSchema, type GraphStats, GraphStatsSchema, HEALTH_GRADES, type HealthIssue, HealthIssueSchema, type HealthRequest, HealthRequestSchema, type HealthResponse, HealthResponseSchema, type HealthScore, type Issue, type IssueSeverity, type MissingDependency, MissingDependencySchema, type PackageDeadCodeResult, type PackageInfo, type PackageStats, QUALITY_BASE_PATH, QUALITY_CACHE_PREFIX, QUALITY_ENV_VARS, QUALITY_FULL_ROUTES, QUALITY_ROUTES, type QualityRoute, type Recommendation, type RepositoryInfo, type RepositoryStats, type StaleChain, StaleChainSchema, type StalePackage, StalePackageSchema, type StaleRequest, StaleRequestSchema, type StaleResponse, StaleResponseSchema, type StatsRequest, StatsRequestSchema, type StatsResponse, StatsResponseSchema, type StatsResult, type TestRunResult, type TypeAnalysisResult, type UnusedDependency, UnusedDependencySchema, type VersionInfo, VersionInfoSchema };