distill-mcp 0.6.0-beta

package/dist/cache/smart-cache.js

@@ -0,0 +1,266 @@
+/**
+ * Smart Cache Implementation
+ *
+ * LRU cache with TTL and file hash validation.
+ * Designed for caching parsed file content but works for any data.
+ */
+import { computeFastFileHash, validateFileHash } from "./file-hash.js";
+/** Default cache configuration */
+const DEFAULT_CONFIG = {
+    maxEntries: 100,
+    defaultTtlMs: 30 * 60 * 1000, // 30 minutes
+    maxMemoryBytes: 50 * 1024 * 1024, // 50MB
+    enableFileHashValidation: true,
+    cleanupInterval: 50,
+};
+/**
+ * Smart Cache class with LRU eviction, TTL expiration, and file hash validation
+ */
+export class SmartCache {
+    cache;
+    config;
+    stats;
+    operationCount;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.cache = new Map();
+        this.operationCount = 0;
+        this.stats = {
+            entries: 0,
+            hits: 0,
+            misses: 0,
+            hitRate: 0,
+            tokensSaved: 0,
+            memorySizeBytes: 0,
+            evictions: 0,
+            invalidations: 0,
+        };
+    }
+    /**
+     * Get a value from cache with automatic validation
+     */
+    async get(key) {
+        this.operationCount++;
+        this.maybeCleanup();
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            this.updateHitRate();
+            return { hit: false, missReason: "not_found" };
+        }
+        // Check TTL expiration
+        const ttl = entry.ttl ?? this.config.defaultTtlMs;
+        const age = Date.now() - entry.createdAt;
+        if (age > ttl) {
+            this.cache.delete(key);
+            this.stats.entries--;
+            this.stats.memorySizeBytes -= entry.sizeBytes;
+            this.stats.misses++;
+            this.updateHitRate();
+            return { hit: false, missReason: "expired" };
+        }
+        // Check file hash validation (if applicable)
+        if (this.config.enableFileHashValidation &&
+            entry.filePath &&
+            entry.fileHash) {
+            const isValid = await validateFileHash(entry.filePath, entry.fileHash);
+            if (!isValid) {
+                this.cache.delete(key);
+                this.stats.entries--;
+                this.stats.memorySizeBytes -= entry.sizeBytes;
+                this.stats.invalidations++;
+                this.stats.misses++;
+                this.updateHitRate();
+                return { hit: false, missReason: "file_changed" };
+            }
+        }
+        // Update last accessed time (for LRU)
+        entry.lastAccessedAt = Date.now();
+        // Update stats
+        this.stats.hits++;
+        if (entry.tokenCount) {
+            this.stats.tokensSaved += entry.tokenCount;
+        }
+        this.updateHitRate();
+        return { hit: true, value: entry.value };
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, options = {}) {
+        this.operationCount++;
+        // Compute size estimate
+        const sizeBytes = this.estimateSize(value);
+        // Compute file hash if path provided
+        let fileHash = options.fileHash;
+        if (!fileHash &&
+            options.filePath &&
+            this.config.enableFileHashValidation) {
+            const hashInfo = await computeFastFileHash(options.filePath);
+            fileHash = hashInfo?.hash;
+        }
+        // Check if we need to evict entries
+        await this.ensureCapacity(sizeBytes);
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            lastAccessedAt: Date.now(),
+            ttl: options.ttl,
+            fileHash,
+            filePath: options.filePath,
+            sizeBytes,
+            tokenCount: options.tokenCount,
+        };
+        // Remove old entry stats if exists
+        const existing = this.cache.get(key);
+        if (existing) {
+            this.stats.memorySizeBytes -= existing.sizeBytes;
+        }
+        else {
+            this.stats.entries++;
+        }
+        this.cache.set(key, entry);
+        this.stats.memorySizeBytes += sizeBytes;
+        this.maybeCleanup();
+    }
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.cache.delete(key);
+            this.stats.entries--;
+            this.stats.memorySizeBytes -= entry.sizeBytes;
+            this.stats.invalidations++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Invalidate all entries for a specific file path
+     */
+    invalidateByPath(filePath) {
+        let count = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.filePath === filePath) {
+                this.cache.delete(key);
+                this.stats.entries--;
+                this.stats.memorySizeBytes -= entry.sizeBytes;
+                this.stats.invalidations++;
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.stats.entries = 0;
+        this.stats.memorySizeBytes = 0;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get list of cached keys (for debugging/inspection)
+     */
+    getKeys() {
+        return Array.from(this.cache.keys());
+    }
+    /**
+     * Check if a key exists (without updating access time)
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+    /**
+     * Get the number of entries in cache
+     */
+    get size() {
+        return this.cache.size;
+    }
+    // Private methods
+    updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate =
+            total > 0 ? Math.round((this.stats.hits / total) * 1000) / 10 : 0;
+    }
+    estimateSize(value) {
+        // Rough estimation based on JSON serialization
+        try {
+            const json = JSON.stringify(value);
+            return json.length * 2; // UTF-16 encoding
+        }
+        catch {
+            return 1024; // Default 1KB for non-serializable
+        }
+    }
+    async ensureCapacity(newEntrySize) {
+        // Check entry count limit
+        while (this.cache.size >= this.config.maxEntries) {
+            this.evictLRU();
+        }
+        // Check memory limit
+        while (this.stats.memorySizeBytes + newEntrySize > this.config.maxMemoryBytes &&
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    evictLRU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.lastAccessedAt < oldestTime) {
+                oldestTime = entry.lastAccessedAt;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            this.cache.delete(oldestKey);
+            this.stats.entries--;
+            this.stats.memorySizeBytes -= entry.sizeBytes;
+            this.stats.evictions++;
+        }
+    }
+    maybeCleanup() {
+        if (this.operationCount % this.config.cleanupInterval !== 0) {
+            return;
+        }
+        this.cleanupExpired();
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            const ttl = entry.ttl ?? this.config.defaultTtlMs;
+            if (now - entry.createdAt > ttl) {
+                this.cache.delete(key);
+                this.stats.entries--;
+                this.stats.memorySizeBytes -= entry.sizeBytes;
+            }
+        }
+    }
+}
+// Singleton instance for session-wide caching
+let globalCache = null;
+/**
+ * Get the global cache instance (creates one if needed)
+ */
+export function getGlobalCache() {
+    if (!globalCache) {
+        globalCache = new SmartCache();
+    }
+    return globalCache;
+}
+/**
+ * Reset the global cache (for testing or explicit reset)
+ */
+export function resetGlobalCache() {
+    globalCache = null;
+}

package/dist/cache/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Smart Cache Types
+ *
+ * Type definitions for the LRU cache with TTL and file hash validation.
+ */
+/**
+ * A single cache entry with metadata
+ */
+export interface CacheEntry<T = unknown> {
+    /** The cached value */
+    value: T;
+    /** When this entry was created (timestamp) */
+    createdAt: number;
+    /** When this entry was last accessed (for LRU eviction) */
+    lastAccessedAt: number;
+    /** TTL in milliseconds (entry-specific, overrides default) */
+    ttl?: number;
+    /** File hash for validation (optional, used for file-based caches) */
+    fileHash?: string;
+    /** Original file path (if applicable) */
+    filePath?: string;
+    /** Size in bytes (approximate, for memory tracking) */
+    sizeBytes: number;
+    /** Token count (for stats tracking) */
+    tokenCount?: number;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /** Total number of entries */
+    entries: number;
+    /** Cache hits since session start */
+    hits: number;
+    /** Cache misses since session start */
+    misses: number;
+    /** Hit rate percentage (0-100) */
+    hitRate: number;
+    /** Total tokens saved via cache hits */
+    tokensSaved: number;
+    /** Approximate memory usage in bytes */
+    memorySizeBytes: number;
+    /** Number of entries evicted (LRU or TTL) */
+    evictions: number;
+    /** Number of entries invalidated due to file change */
+    invalidations: number;
+}
+/**
+ * Cache configuration options
+ */
+export interface CacheConfig {
+    /** Maximum number of entries (default: 100) */
+    maxEntries: number;
+    /** Default TTL in milliseconds (default: 30 minutes) */
+    defaultTtlMs: number;
+    /** Maximum memory size in bytes (default: 50MB) */
+    maxMemoryBytes: number;
+    /** Enable file hash validation (default: true) */
+    enableFileHashValidation: boolean;
+    /** Cleanup interval in operations (default: 50) */
+    cleanupInterval: number;
+}
+/**
+ * Options for setting a cache entry
+ */
+export interface SmartCacheOptions {
+    /** Optional TTL override for this entry */
+    ttl?: number;
+    /** File path for hash validation */
+    filePath?: string;
+    /** Pre-computed file hash (if already available) */
+    fileHash?: string;
+    /** Token count for stats */
+    tokenCount?: number;
+}
+/**
+ * Cache key type
+ */
+export type CacheKey = string;
+/**
+ * Result of a cache get operation
+ */
+export interface CacheGetResult<T> {
+    /** Whether the entry was found and valid */
+    hit: boolean;
+    /** The cached value (undefined if miss) */
+    value?: T;
+    /** Reason for miss (if applicable) */
+    missReason?: "not_found" | "expired" | "file_changed" | "evicted";
+}
+/**
+ * File hash information
+ */
+export interface FileHashInfo {
+    /** The computed hash string */
+    hash: string;
+    /** File modification time in milliseconds */
+    mtime: number;
+    /** File size in bytes */
+    size: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cache/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,uBAAuB;IACvB,KAAK,EAAE,CAAC,CAAC;IAET,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAElB,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IAEvB,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAElB,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAEhB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IAEb,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IAEf,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAEhB,wCAAwC;IACxC,WAAW,EAAE,MAAM,CAAC;IAEpB,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;IAExB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAElB,uDAAuD;IACvD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IAEnB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IAErB,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAC;IAEvB,kDAAkD;IAClD,wBAAwB,EAAE,OAAO,CAAC;IAElC,mDAAmD;IACnD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,4CAA4C;IAC5C,GAAG,EAAE,OAAO,CAAC;IAEb,2CAA2C;IAC3C,KAAK,CAAC,EAAE,CAAC,CAAC;IAEV,sCAAsC;IACtC,UAAU,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CAAC;CACnE;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IAEb,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IAEd,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/cache/types.js

@@ -0,0 +1,6 @@
+/**
+ * Smart Cache Types
+ *
+ * Type definitions for the LRU cache with TTL and file hash validation.
+ */
+export {};

package/dist/cli/analyze.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CLI Analyze Command
+ *
+ * Analyzes files for token usage and optimization opportunities.
+ * Used by both CLI and GitHub Action.
+ */
+export interface AnalyzeOptions {
+    patterns: string[];
+    threshold: number;
+    json: boolean;
+    workingDir: string;
+}
+export interface FileAnalysis {
+    file: string;
+    tokens: number;
+    lines: number;
+    language: string;
+    exceedsThreshold: boolean;
+    suggestion?: string;
+}
+export interface AnalyzeReport {
+    timestamp: string;
+    workingDir: string;
+    threshold: number;
+    totalFiles: number;
+    totalTokens: number;
+    filesAboveThreshold: number;
+    files: FileAnalysis[];
+    recommendations: string[];
+}
+/**
+ * Analyze files and generate report
+ */
+export declare function analyzeFiles(options: AnalyzeOptions): Promise<AnalyzeReport>;
+/**
+ * Format report as text table
+ */
+export declare function formatReportAsText(report: AnalyzeReport): string;
+/**
+ * Run analyze command
+ */
+export declare function runAnalyze(args: string[]): Promise<void>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/cli/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/cli/analyze.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAqHD;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA0ElF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAkChE;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8C9D"}

package/dist/cli/analyze.js

@@ -0,0 +1,250 @@
+/**
+ * CLI Analyze Command
+ *
+ * Analyzes files for token usage and optimization opportunities.
+ * Used by both CLI and GitHub Action.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { countTokens } from "../utils/token-counter.js";
+const LANGUAGE_MAP = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".php": "php",
+    ".swift": "swift",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+};
+/**
+ * Match files against glob patterns (simple implementation)
+ */
+function matchGlob(filepath, pattern) {
+    // Handle brace expansion: {a,b,c} -> (a|b|c)
+    let regexPattern = pattern.replace(/\{([^}]+)\}/g, (_match, group) => {
+        const alternatives = group.split(",").map((s) => s.trim());
+        return `(${alternatives.join("|")})`;
+    });
+    regexPattern = regexPattern
+        .replace(/\*\*\//g, "(.*/)?")
+        .replace(/\*\*/g, ".*")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, ".")
+        .replace(/\./g, "\\.");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(filepath);
+}
+/**
+ * Walk directory and find matching files
+ */
+function walkDirectory(dir, patterns, maxFiles = 1000) {
+    const results = [];
+    function walk(currentDir, relativePath = "") {
+        if (results.length >= maxFiles)
+            return;
+        try {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (results.length >= maxFiles)
+                    break;
+                const fullPath = path.join(currentDir, entry.name);
+                const relPath = path.join(relativePath, entry.name);
+                // Skip hidden dirs and node_modules
+                if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    walk(fullPath, relPath);
+                }
+                else if (entry.isFile()) {
+                    for (const pattern of patterns) {
+                        if (matchGlob(relPath, pattern)) {
+                            results.push(relPath);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    walk(dir);
+    return results;
+}
+/**
+ * Get optimization suggestion based on file characteristics
+ */
+function getSuggestion(tokens, language) {
+    if (tokens > 5000) {
+        if (["typescript", "javascript", "python", "go", "rust"].includes(language)) {
+            return "Use smart_file_read to extract specific functions/classes";
+        }
+        return "Consider using code_skeleton to get signatures only";
+    }
+    if (tokens > 2000) {
+        return "Consider using semantic_compress for this file";
+    }
+    return undefined;
+}
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(filepath) {
+    const ext = path.extname(filepath).toLowerCase();
+    return LANGUAGE_MAP[ext] || "unknown";
+}
+/**
+ * Analyze files and generate report
+ */
+export async function analyzeFiles(options) {
+    const { patterns, threshold, workingDir } = options;
+    // Find matching files
+    const files = walkDirectory(workingDir, patterns);
+    // Analyze each file
+    const analyses = [];
+    let totalTokens = 0;
+    let filesAboveThreshold = 0;
+    for (const file of files) {
+        try {
+            const fullPath = path.join(workingDir, file);
+            const content = fs.readFileSync(fullPath, "utf-8");
+            const tokens = countTokens(content);
+            const lines = content.split("\n").length;
+            const language = detectLanguage(file);
+            const exceedsThreshold = tokens > threshold;
+            if (exceedsThreshold) {
+                filesAboveThreshold++;
+            }
+            totalTokens += tokens;
+            analyses.push({
+                file,
+                tokens,
+                lines,
+                language,
+                exceedsThreshold,
+                suggestion: exceedsThreshold ? getSuggestion(tokens, language) : undefined,
+            });
+        }
+        catch {
+            // Skip files we can't read
+        }
+    }
+    // Sort by tokens descending
+    analyses.sort((a, b) => b.tokens - a.tokens);
+    // Generate recommendations
+    const recommendations = [];
+    if (filesAboveThreshold > 0) {
+        recommendations.push(`${filesAboveThreshold} file(s) exceed the ${threshold} token threshold`);
+    }
+    const veryLargeFiles = analyses.filter((a) => a.tokens > 5000);
+    if (veryLargeFiles.length > 0) {
+        recommendations.push(`${veryLargeFiles.length} file(s) > 5000 tokens - use smart_file_read for targeted extraction`);
+    }
+    if (totalTokens > 50000) {
+        recommendations.push("Large codebase - consider using code_skeleton for overview before detailed reading");
+    }
+    return {
+        timestamp: new Date().toISOString(),
+        workingDir,
+        threshold,
+        totalFiles: files.length,
+        totalTokens,
+        filesAboveThreshold,
+        files: analyses,
+        recommendations,
+    };
+}
+/**
+ * Format report as text table
+ */
+export function formatReportAsText(report) {
+    const lines = [];
+    lines.push("## Token Analysis Report\n");
+    lines.push(`Analyzed: ${report.totalFiles} files`);
+    lines.push(`Total tokens: ${report.totalTokens.toLocaleString()}`);
+    lines.push(`Above threshold (${report.threshold}): ${report.filesAboveThreshold}\n`);
+    if (report.files.length > 0) {
+        lines.push("### Files by Token Count\n");
+        lines.push("| File | Tokens | Lines | Language |");
+        lines.push("|------|--------|-------|----------|");
+        // Show top 20 files
+        for (const file of report.files.slice(0, 20)) {
+            const marker = file.exceedsThreshold ? " ⚠️" : "";
+            lines.push(`| ${file.file}${marker} | ${file.tokens.toLocaleString()} | ${file.lines} | ${file.language} |`);
+        }
+        if (report.files.length > 20) {
+            lines.push(`| ... and ${report.files.length - 20} more files | | | |`);
+        }
+    }
+    if (report.recommendations.length > 0) {
+        lines.push("\n### Recommendations\n");
+        for (const rec of report.recommendations) {
+            lines.push(`- ${rec}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Run analyze command
+ */
+export async function runAnalyze(args) {
+    // Parse arguments
+    let patterns = ["**/*.{ts,tsx,js,jsx,py,go,rs}"];
+    let threshold = 2000;
+    let json = false;
+    let outputFile = null;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--patterns" || arg === "-p") {
+            const patternArg = args[++i];
+            if (patternArg) {
+                patterns = patternArg.split(",");
+            }
+        }
+        else if (arg === "--threshold" || arg === "-t") {
+            const thresholdArg = args[++i];
+            if (thresholdArg) {
+                threshold = parseInt(thresholdArg, 10);
+            }
+        }
+        else if (arg === "--json" || arg === "-j") {
+            json = true;
+        }
+        else if (arg === "--output" || arg === "-o") {
+            outputFile = args[++i] || null;
+        }
+    }
+    const report = await analyzeFiles({
+        patterns,
+        threshold,
+        json,
+        workingDir: process.cwd(),
+    });
+    const output = json ? JSON.stringify(report, null, 2) : formatReportAsText(report);
+    if (outputFile) {
+        fs.writeFileSync(outputFile, output);
+        console.log(`Report written to ${outputFile}`);
+    }
+    else {
+        console.log(output);
+    }
+    // Exit with error code if files exceed threshold
+    if (report.filesAboveThreshold > 0 && !json) {
+        process.exit(1);
+    }
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,2 @@
+export declare function doctor(): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/cli/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAgHA,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CA2C5C"}