distill-mcp 0.6.0-beta

package/dist/utils/language-detector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Language Detector
+ *
+ * Detects programming language from file path extension.
+ */
+import type { SupportedLanguage } from "../ast/types.js";
+/**
+ * Detect language from file path
+ */
+export declare function detectLanguageFromPath(filePath: string): SupportedLanguage;
+/**
+ * Get file extension for a language
+ */
+export declare function getExtensionsForLanguage(language: SupportedLanguage): string[];
+/**
+ * Check if language is supported for AST parsing
+ */
+export declare function isASTSupported(language: SupportedLanguage): boolean;
+/**
+ * Check if language is supported for regex parsing
+ */
+export declare function isRegexSupported(language: SupportedLanguage): boolean;
+/**
+ * Get language display name
+ */
+export declare function getLanguageDisplayName(language: SupportedLanguage): string;
+//# sourceMappingURL=language-detector.d.ts.map

package/dist/utils/language-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../src/utils/language-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AA4CzD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAG1E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAI9E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAEnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAErE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAuB1E"}

package/dist/utils/language-detector.js

@@ -0,0 +1,94 @@
+/**
+ * Language Detector
+ *
+ * Detects programming language from file path extension.
+ */
+import * as path from "path";
+const EXTENSION_MAP = {
+    // TypeScript
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    // JavaScript
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    // Python
+    ".py": "python",
+    ".pyw": "python",
+    ".pyi": "python",
+    // Go
+    ".go": "go",
+    // Rust
+    ".rs": "rust",
+    // PHP
+    ".php": "php",
+    ".phtml": "php",
+    ".php3": "php",
+    ".php4": "php",
+    ".php5": "php",
+    ".php7": "php",
+    ".phps": "php",
+    // Swift
+    ".swift": "swift",
+    // Config files
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+};
+/**
+ * Detect language from file path
+ */
+export function detectLanguageFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return EXTENSION_MAP[ext] ?? "unknown";
+}
+/**
+ * Get file extension for a language
+ */
+export function getExtensionsForLanguage(language) {
+    return Object.entries(EXTENSION_MAP)
+        .filter(([, lang]) => lang === language)
+        .map(([ext]) => ext);
+}
+/**
+ * Check if language is supported for AST parsing
+ */
+export function isASTSupported(language) {
+    return language === "typescript" || language === "javascript";
+}
+/**
+ * Check if language is supported for regex parsing
+ */
+export function isRegexSupported(language) {
+    return language === "python" || language === "go" || language === "rust";
+}
+/**
+ * Get language display name
+ */
+export function getLanguageDisplayName(language) {
+    switch (language) {
+        case "typescript":
+            return "TypeScript";
+        case "javascript":
+            return "JavaScript";
+        case "python":
+            return "Python";
+        case "go":
+            return "Go";
+        case "rust":
+            return "Rust";
+        case "php":
+            return "PHP";
+        case "swift":
+            return "Swift";
+        case "json":
+            return "JSON";
+        case "yaml":
+            return "YAML";
+        case "unknown":
+            return "Unknown";
+    }
+}

package/dist/utils/log-parser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Log Parser Utilities
+ *
+ * Common functions for parsing log files across different formats.
+ */
+import type { LogType, LogLevel, LogEntry, Timespan } from "../summarizers/types.js";
+/**
+ * Extract timestamp from a log line
+ */
+export declare function parseTimestamp(line: string): string | undefined;
+/**
+ * Extract log level from a log line
+ */
+export declare function parseLogLevel(line: string): LogLevel;
+/**
+ * Parse a single log line into a LogEntry
+ */
+export declare function parseLogLine(line: string): LogEntry;
+/**
+ * Detect the type of log based on content patterns
+ */
+export declare function detectLogType(logs: string): LogType;
+/**
+ * Calculate timespan from log entries
+ */
+export declare function calculateTimespan(entries: LogEntry[]): Timespan | undefined;
+/**
+ * Format duration in milliseconds to human readable
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Deduplicate log entries by normalized message
+ */
+export declare function deduplicateEntries(entries: LogEntry[]): LogEntry[];
+/**
+ * Filter entries by time range
+ */
+export declare function filterByTimeframe(entries: LogEntry[], timeframe?: {
+    start?: string;
+    end?: string;
+}): LogEntry[];
+/**
+ * Check if a line indicates a key event
+ */
+export declare function isKeyEvent(line: string): boolean;
+//# sourceMappingURL=log-parser.d.ts.map

package/dist/utils/log-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-parser.d.ts","sourceRoot":"","sources":["../../src/utils/log-parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AA0ErF;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQ/D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAOpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CA4BnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAqBnD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,QAAQ,GAAG,SAAS,CA6B3E;AAyCD;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAgBlE;AAgBD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,QAAQ,EAAE,EACnB,SAAS,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,QAAQ,EAAE,CAmBZ;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAahD"}

package/dist/utils/log-parser.js

@@ -0,0 +1,287 @@
+/**
+ * Log Parser Utilities
+ *
+ * Common functions for parsing log files across different formats.
+ */
+/**
+ * Timestamp patterns for common log formats
+ */
+const TIMESTAMP_PATTERNS = [
+    // ISO 8601: 2024-01-15T10:30:45.123Z or 2024-01-15 10:30:45
+    /(\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/,
+    // Bracket format: [10:30:45] or [2024-01-15 10:30:45]
+    /\[(\d{4}-\d{2}-\d{2}\s+)?\d{2}:\d{2}:\d{2}(?:\.\d+)?\]/,
+    // Syslog: Jan 15 10:30:45
+    /([A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})/,
+    // Unix timestamp: 1705315845
+    /\b(\d{10,13})\b/,
+    // Time only: 10:30:45.123
+    /\b(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\b/,
+];
+/**
+ * Log level patterns
+ */
+const LOG_LEVEL_PATTERNS = [
+    { pattern: /\b(ERROR|ERR|FATAL|CRITICAL)\b/i, level: "error" },
+    { pattern: /\b(WARN(?:ING)?)\b/i, level: "warning" },
+    { pattern: /\b(INFO)\b/i, level: "info" },
+    { pattern: /\b(DEBUG|TRACE|VERBOSE)\b/i, level: "debug" },
+];
+/**
+ * Log type detection patterns
+ */
+const LOG_TYPE_PATTERNS = [
+    {
+        type: "server",
+        patterns: [
+            /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+\/\S+\s+\d{3}/,
+            /\bHTTP\/\d\.\d\b/,
+            /\b(request|response|endpoint)\b/i,
+            /\bstatus\s*[:=]\s*\d{3}\b/i,
+        ],
+        threshold: 0.1, // 10% of lines
+    },
+    {
+        type: "test",
+        patterns: [
+            /\b(PASS|FAIL|SKIP|PENDING)\b/,
+            /\b(describe|it|test|expect|assert)\s*\(/,
+            /\b(jest|mocha|vitest|pytest|unittest)\b/i,
+            /\bTest\s+(Suites?|Cases?)\b/i,
+            /✓|✕|●/,
+        ],
+        threshold: 0.05, // 5% of lines
+    },
+    {
+        type: "build",
+        patterns: [
+            /\b(webpack|vite|esbuild|rollup|parcel)\b/i,
+            /\b(tsc|typescript|Compiling|Bundling)\b/i,
+            /\b(npm|yarn|pnpm|bun)\s+(run|build|install)\b/i,
+            /\bBuilt?\s+in\s+\d+/i,
+            /\.(js|ts|tsx|jsx|css|scss)\s+\d+(\.\d+)?\s*(KB|MB|bytes)/i,
+        ],
+        threshold: 0.05,
+    },
+    {
+        type: "application",
+        patterns: [
+            /\[\s*(INFO|DEBUG|WARN|ERROR|TRACE|FATAL)\s*\]/i,
+            /\b(INFO|DEBUG|WARN|ERROR)\s*[-:]/i,
+        ],
+        threshold: 0.3, // 30% of lines
+    },
+];
+/**
+ * Extract timestamp from a log line
+ */
+export function parseTimestamp(line) {
+    for (const pattern of TIMESTAMP_PATTERNS) {
+        const match = line.match(pattern);
+        if (match) {
+            return match[1] ?? match[0];
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract log level from a log line
+ */
+export function parseLogLevel(line) {
+    for (const { pattern, level } of LOG_LEVEL_PATTERNS) {
+        if (pattern.test(line)) {
+            return level;
+        }
+    }
+    return "info"; // Default
+}
+/**
+ * Parse a single log line into a LogEntry
+ */
+export function parseLogLine(line) {
+    const trimmed = line.trim();
+    const timestamp = parseTimestamp(trimmed);
+    const level = parseLogLevel(trimmed);
+    // Extract message by removing timestamp and level prefix
+    let message = trimmed;
+    // Remove timestamp
+    if (timestamp) {
+        message = message.replace(timestamp, "").trim();
+    }
+    // Remove level indicator
+    message = message
+        .replace(/^\[?\s*(ERROR|WARN(?:ING)?|INFO|DEBUG|TRACE|FATAL)\s*\]?\s*[-:.]?\s*/i, "")
+        .trim();
+    // Remove leading brackets/dashes
+    message = message.replace(/^[\[\]\-:]+\s*/, "").trim();
+    return {
+        timestamp,
+        level,
+        message: message || trimmed,
+        count: 1,
+        raw: trimmed,
+    };
+}
+/**
+ * Detect the type of log based on content patterns
+ */
+export function detectLogType(logs) {
+    const lines = logs.split("\n").filter((l) => l.trim());
+    const totalLines = lines.length;
+    if (totalLines === 0)
+        return "generic";
+    // Check each log type
+    for (const { type, patterns, threshold } of LOG_TYPE_PATTERNS) {
+        let matchingLines = 0;
+        for (const line of lines) {
+            if (patterns.some((p) => p.test(line))) {
+                matchingLines++;
+            }
+        }
+        if (matchingLines / totalLines >= threshold) {
+            return type;
+        }
+    }
+    return "generic";
+}
+/**
+ * Calculate timespan from log entries
+ */
+export function calculateTimespan(entries) {
+    const timestamps = [];
+    for (const entry of entries) {
+        if (entry.timestamp) {
+            const date = parseDate(entry.timestamp);
+            if (date) {
+                timestamps.push(date);
+            }
+        }
+    }
+    if (timestamps.length < 2)
+        return undefined;
+    timestamps.sort((a, b) => a.getTime() - b.getTime());
+    const start = timestamps[0];
+    const end = timestamps[timestamps.length - 1];
+    if (!start || !end)
+        return undefined;
+    const durationMs = end.getTime() - start.getTime();
+    return {
+        start: formatTimestamp(start),
+        end: formatTimestamp(end),
+        durationMs,
+        durationFormatted: formatDuration(durationMs),
+    };
+}
+/**
+ * Parse a timestamp string into a Date
+ */
+function parseDate(timestamp) {
+    // Try ISO format first
+    const isoDate = new Date(timestamp);
+    if (!isNaN(isoDate.getTime())) {
+        return isoDate;
+    }
+    // Try Unix timestamp (seconds or milliseconds)
+    const unixMatch = timestamp.match(/^(\d{10,13})$/);
+    if (unixMatch) {
+        const ts = parseInt(unixMatch[1] ?? "0", 10);
+        return new Date(ts.toString().length === 10 ? ts * 1000 : ts);
+    }
+    // Try time only (assume today)
+    const timeMatch = timestamp.match(/^(\d{2}):(\d{2}):(\d{2})/);
+    if (timeMatch) {
+        const now = new Date();
+        now.setHours(parseInt(timeMatch[1] ?? "0", 10), parseInt(timeMatch[2] ?? "0", 10), parseInt(timeMatch[3] ?? "0", 10));
+        return now;
+    }
+    return undefined;
+}
+/**
+ * Format a Date as a readable timestamp
+ */
+function formatTimestamp(date) {
+    return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+}
+/**
+ * Format duration in milliseconds to human readable
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600000)
+        return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor((ms % 3600000) / 60000);
+    return `${hours}h ${minutes}m`;
+}
+/**
+ * Deduplicate log entries by normalized message
+ */
+export function deduplicateEntries(entries) {
+    const groups = new Map();
+    for (const entry of entries) {
+        // Normalize message for grouping
+        const key = normalizeForGrouping(entry.message);
+        if (groups.has(key)) {
+            const existing = groups.get(key);
+            existing.count++;
+        }
+        else {
+            groups.set(key, { ...entry });
+        }
+    }
+    return Array.from(groups.values()).sort((a, b) => b.count - a.count);
+}
+/**
+ * Normalize a message for grouping similar entries
+ */
+function normalizeForGrouping(message) {
+    return message
+        .replace(/\d+(\.\d+)?/g, "<N>") // Numbers
+        .replace(/[a-f0-9]{8,}/gi, "<HASH>") // Hashes
+        .replace(/\/[\w\-\.\/]+/g, "<PATH>") // Paths
+        .replace(/'[^']*'/g, "'<STR>'") // Single quoted strings
+        .replace(/"[^"]*"/g, '"<STR>"') // Double quoted strings
+        .toLowerCase()
+        .trim();
+}
+/**
+ * Filter entries by time range
+ */
+export function filterByTimeframe(entries, timeframe) {
+    if (!timeframe || (!timeframe.start && !timeframe.end)) {
+        return entries;
+    }
+    const startDate = timeframe.start ? parseDate(timeframe.start) : undefined;
+    const endDate = timeframe.end ? parseDate(timeframe.end) : undefined;
+    return entries.filter((entry) => {
+        if (!entry.timestamp)
+            return true;
+        const entryDate = parseDate(entry.timestamp);
+        if (!entryDate)
+            return true;
+        if (startDate && entryDate < startDate)
+            return false;
+        if (endDate && entryDate > endDate)
+            return false;
+        return true;
+    });
+}
+/**
+ * Check if a line indicates a key event
+ */
+export function isKeyEvent(line) {
+    const keyEventPatterns = [
+        /\b(start(?:ed|ing)?|stop(?:ped|ping)?|shutdown|restart)\b/i,
+        /\b(connect(?:ed|ing)?|disconnect(?:ed|ing)?|reconnect)\b/i,
+        /\b(initialized?|ready|listening)\b/i,
+        /\b(crash(?:ed)?|panic|abort(?:ed)?)\b/i,
+        /\b(deploy(?:ed|ing)?|release|version)\b/i,
+        /\b(ERROR|FATAL|CRITICAL)\b/i,
+        /\bport\s+\d+\b/i,
+        /\bserver\b/i,
+    ];
+    return keyEventPatterns.some((p) => p.test(line));
+}

package/dist/utils/output-estimator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Output Token Estimator
+ *
+ * Heuristic-based estimation of LLM output tokens based on:
+ * - Content type (code, logs, questions, instructions)
+ * - Input length
+ * - Content patterns
+ */
+import type { ContentType } from "../compressors/types.js";
+/**
+ * Output estimation result
+ */
+export interface OutputEstimate {
+    /** Estimated output tokens */
+    estimated: number;
+    /** Confidence level of the estimate */
+    confidence: "low" | "medium" | "high";
+    /** Human-readable reasoning for the estimate */
+    reasoning: string;
+}
+/**
+ * Output ratio configuration per content type
+ */
+interface OutputRatio {
+    /** Minimum output/input ratio */
+    minRatio: number;
+    /** Maximum output/input ratio */
+    maxRatio: number;
+    /** Default output/input ratio */
+    defaultRatio: number;
+}
+/**
+ * Detect if content is a question
+ */
+export declare function isQuestion(content: string): boolean;
+/**
+ * Detect if content is an instruction/command
+ */
+export declare function isInstruction(content: string): boolean;
+/**
+ * Estimate output tokens based on content analysis
+ *
+ * @param content - The input content
+ * @param inputTokens - Pre-calculated input token count
+ * @param contentType - Detected content type
+ * @returns Estimation with confidence and reasoning
+ */
+export declare function estimateOutputTokens(content: string, inputTokens: number, contentType: ContentType): OutputEstimate;
+/**
+ * Get the output ratio for a content type (for display purposes)
+ */
+export declare function getOutputRatio(contentType: ContentType): OutputRatio;
+export {};
+//# sourceMappingURL=output-estimator.d.ts.map

package/dist/utils/output-estimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-estimator.d.ts","sourceRoot":"","sources":["../../src/utils/output-estimator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,UAAU,WAAW;IACnB,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB;AAkDD;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGtD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,WAAW,GACvB,cAAc,CAmDhB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAEpE"}

package/dist/utils/output-estimator.js

@@ -0,0 +1,119 @@
+/**
+ * Output Token Estimator
+ *
+ * Heuristic-based estimation of LLM output tokens based on:
+ * - Content type (code, logs, questions, instructions)
+ * - Input length
+ * - Content patterns
+ */
+/**
+ * Output estimation ratios by content type
+ * Based on typical LLM response patterns
+ */
+const OUTPUT_RATIOS = {
+    // Code input often results in code output (similar length)
+    code: { minRatio: 0.3, maxRatio: 1.5, defaultRatio: 0.8 },
+    // Logs/errors need concise summaries
+    logs: { minRatio: 0.1, maxRatio: 0.3, defaultRatio: 0.2 },
+    stacktrace: { minRatio: 0.1, maxRatio: 0.4, defaultRatio: 0.25 },
+    // Config analysis is usually brief
+    config: { minRatio: 0.2, maxRatio: 0.5, defaultRatio: 0.3 },
+    // Generic text might get similar-length responses
+    generic: { minRatio: 0.3, maxRatio: 1.0, defaultRatio: 0.5 },
+    // Questions typically get expansive answers
+    question: { minRatio: 0.5, maxRatio: 2.0, defaultRatio: 1.0 },
+    // Instructions (do X) get acknowledgment + result
+    instruction: { minRatio: 0.3, maxRatio: 1.5, defaultRatio: 0.6 },
+};
+/**
+ * Patterns that indicate a question
+ */
+const QUESTION_PATTERNS = [
+    /^(what|how|why|when|where|who|which|can|could|would|should|is|are|do|does)\b/i,
+    /\?[\s]*$/,
+    /\b(explain|describe|tell me|help me understand|what is|what are)\b/i,
+];
+/**
+ * Patterns that indicate an instruction/command
+ */
+const INSTRUCTION_PATTERNS = [
+    /^(create|write|build|implement|add|remove|fix|update|change|modify|generate|make|refactor)\b/i,
+    /^(please|can you|could you|would you|I need you to|I want you to)\b/i,
+    /\b(write a|create a|build a|implement a|add a|generate a)\b/i,
+];
+/**
+ * Detect if content is a question
+ */
+export function isQuestion(content) {
+    const trimmed = content.trim();
+    return QUESTION_PATTERNS.some((p) => p.test(trimmed));
+}
+/**
+ * Detect if content is an instruction/command
+ */
+export function isInstruction(content) {
+    const trimmed = content.trim();
+    return INSTRUCTION_PATTERNS.some((p) => p.test(trimmed));
+}
+/**
+ * Estimate output tokens based on content analysis
+ *
+ * @param content - The input content
+ * @param inputTokens - Pre-calculated input token count
+ * @param contentType - Detected content type
+ * @returns Estimation with confidence and reasoning
+ */
+export function estimateOutputTokens(content, inputTokens, contentType) {
+    // Determine effective content type by checking conversational patterns
+    let effectiveType = contentType;
+    if (contentType === "generic") {
+        if (isQuestion(content)) {
+            effectiveType = "question";
+        }
+        else if (isInstruction(content)) {
+            effectiveType = "instruction";
+        }
+    }
+    const ratios = OUTPUT_RATIOS[effectiveType];
+    // Base estimation using default ratio
+    let estimated = Math.round(inputTokens * ratios.defaultRatio);
+    let confidence = "medium";
+    let reasoning = "";
+    // Adjust based on input length
+    if (inputTokens < 100) {
+        // Short inputs often get longer outputs (elaboration needed)
+        estimated = Math.max(estimated, Math.round(inputTokens * ratios.maxRatio));
+        confidence = "low";
+        reasoning = "Short input - output length may vary significantly";
+    }
+    else if (inputTokens > 10000) {
+        // Very long inputs typically get more concise responses
+        estimated = Math.round(inputTokens * ratios.minRatio);
+        confidence = "medium";
+        reasoning = "Long input - expecting summarized/focused response";
+    }
+    else {
+        confidence = "medium";
+        reasoning = `Based on ${effectiveType} content pattern (${ratios.defaultRatio}x ratio)`;
+    }
+    // Apply minimum floor (responses are rarely < 50 tokens)
+    const MIN_OUTPUT = 50;
+    if (estimated < MIN_OUTPUT) {
+        estimated = MIN_OUTPUT;
+        reasoning += "; minimum output floor applied";
+    }
+    // Apply maximum ceiling (practical limit for single response)
+    const MAX_OUTPUT = 16000;
+    if (estimated > MAX_OUTPUT) {
+        estimated = MAX_OUTPUT;
+        confidence = "low";
+        reasoning = "Very long input - capped at practical response limit";
+    }
+    return { estimated, confidence, reasoning };
+}
+/**
+ * Get the output ratio for a content type (for display purposes)
+ */
+export function getOutputRatio(contentType) {
+    return OUTPUT_RATIOS[contentType] || OUTPUT_RATIOS.generic;
+}

package/dist/utils/output-estimator.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Output Estimator Tests
+ */
+export {};
+//# sourceMappingURL=output-estimator.test.d.ts.map

package/dist/utils/output-estimator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-estimator.test.d.ts","sourceRoot":"","sources":["../../src/utils/output-estimator.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}