distill-mcp 0.6.0-beta

package/dist/summarizers/server-logs.js

@@ -0,0 +1,215 @@
+/**
+ * Server Logs Summarizer
+ *
+ * Summarizes HTTP server logs with request statistics, response times, and error tracking.
+ */
+import { parseLogLine, parseTimestamp, calculateTimespan, deduplicateEntries, filterByTimeframe, isKeyEvent, } from "../utils/log-parser.js";
+import { MAX_ENTRIES } from "./types.js";
+/**
+ * HTTP request pattern: GET /api/users 200 45ms
+ */
+const HTTP_REQUEST_PATTERN = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S*)\s+(\d{3})(?:\s+(\d+(?:\.\d+)?)\s*m?s)?/i;
+/**
+ * Alternative patterns for different log formats
+ */
+const ALT_PATTERNS = [
+    // nginx/apache: "GET /path HTTP/1.1" 200 1234
+    /"(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S*)\s+HTTP\/[\d.]+"\s+(\d{3})/i,
+    // status=200 path=/api/users method=GET
+    /method[=:]\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS).*path[=:]\s*(\/\S*).*status[=:]\s*(\d{3})/i,
+];
+/**
+ * Parse an HTTP request from a log line
+ */
+function parseHttpRequest(line) {
+    // Try main pattern
+    let match = line.match(HTTP_REQUEST_PATTERN);
+    if (match) {
+        return {
+            timestamp: parseTimestamp(line),
+            method: (match[1] ?? "GET").toUpperCase(),
+            path: match[2] ?? "/",
+            statusCode: parseInt(match[3] ?? "0", 10),
+            responseTime: match[4] ? parseFloat(match[4]) : undefined,
+            raw: line,
+        };
+    }
+    // Try alternative patterns
+    for (const pattern of ALT_PATTERNS) {
+        match = line.match(pattern);
+        if (match) {
+            return {
+                timestamp: parseTimestamp(line),
+                method: (match[1] ?? "GET").toUpperCase(),
+                path: match[2] ?? "/",
+                statusCode: parseInt(match[3] ?? "0", 10),
+                raw: line,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Normalize path for grouping (remove IDs and query strings)
+ */
+function normalizePath(path) {
+    return path
+        .split("?")[0] // Remove query string
+        ?.replace(/\/\d+/g, "/:id") // Replace numeric IDs
+        .replace(/\/[a-f0-9-]{36}/gi, "/:uuid") // Replace UUIDs
+        .replace(/\/[a-f0-9]{24}/gi, "/:id") ?? path; // Replace MongoDB ObjectIds
+}
+/**
+ * Server logs summarizer
+ */
+export const serverLogsSummarizer = {
+    name: "server-logs",
+    logType: "server",
+    canSummarize(logs) {
+        const lines = logs.split("\n").slice(0, 100); // Sample first 100 lines
+        let matches = 0;
+        for (const line of lines) {
+            if (HTTP_REQUEST_PATTERN.test(line) || ALT_PATTERNS.some((p) => p.test(line))) {
+                matches++;
+            }
+        }
+        return matches / lines.length >= 0.1; // At least 10% HTTP requests
+    },
+    summarize(logs, options) {
+        const lines = logs.split("\n").filter((l) => l.trim());
+        const requests = [];
+        const errors = [];
+        const warnings = [];
+        const keyEvents = [];
+        const allEntries = [];
+        // Parse all lines
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Try to parse as HTTP request
+            const request = parseHttpRequest(trimmed);
+            if (request) {
+                requests.push(request);
+                // Check for error status codes
+                if (request.statusCode >= 500) {
+                    errors.push({
+                        timestamp: request.timestamp,
+                        level: "error",
+                        message: `${request.method} ${request.path} → ${request.statusCode}`,
+                        count: 1,
+                        raw: trimmed,
+                    });
+                }
+                else if (request.statusCode >= 400) {
+                    warnings.push({
+                        timestamp: request.timestamp,
+                        level: "warning",
+                        message: `${request.method} ${request.path} → ${request.statusCode}`,
+                        count: 1,
+                        raw: trimmed,
+                    });
+                }
+            }
+            // Parse as regular log entry
+            const entry = parseLogLine(trimmed);
+            allEntries.push(entry);
+            // Collect errors and warnings from non-request lines
+            if (!request) {
+                if (entry.level === "error") {
+                    errors.push(entry);
+                }
+                else if (entry.level === "warning") {
+                    warnings.push(entry);
+                }
+            }
+            // Detect key events
+            if (isKeyEvent(trimmed)) {
+                keyEvents.push(entry);
+            }
+        }
+        // Filter by timeframe if specified
+        const filteredEntries = filterByTimeframe(allEntries, options.timeframe);
+        // Calculate endpoint statistics
+        const endpointStats = new Map();
+        const statusCodes = new Map();
+        for (const req of requests) {
+            const key = `${req.method} ${normalizePath(req.path)}`;
+            const stats = endpointStats.get(key) || { count: 0, totalTime: 0, errorCount: 0 };
+            stats.count++;
+            if (req.responseTime) {
+                stats.totalTime += req.responseTime;
+            }
+            if (req.statusCode >= 400) {
+                stats.errorCount++;
+            }
+            endpointStats.set(key, stats);
+            // Track status codes
+            statusCodes.set(req.statusCode, (statusCodes.get(req.statusCode) || 0) + 1);
+        }
+        // Calculate timespan
+        const timespan = calculateTimespan(filteredEntries);
+        // Build endpoint array
+        const endpoints = Array.from(endpointStats.entries())
+            .map(([key, stats]) => {
+            const [method, path] = key.split(" ");
+            return {
+                method: method ?? "GET",
+                path: path ?? "/",
+                count: stats.count,
+                avgTime: stats.count > 0 ? Math.round(stats.totalTime / stats.count) : 0,
+                errorCount: stats.errorCount,
+            };
+        })
+            .sort((a, b) => b.count - a.count);
+        // Calculate average response time
+        const totalTime = requests.reduce((sum, r) => sum + (r.responseTime || 0), 0);
+        const requestsWithTime = requests.filter((r) => r.responseTime !== undefined).length;
+        const avgResponseTime = requestsWithTime > 0 ? Math.round(totalTime / requestsWithTime) : 0;
+        // Deduplicate errors and warnings
+        const deduplicatedErrors = deduplicateEntries(errors);
+        const deduplicatedWarnings = deduplicateEntries(warnings);
+        // Build statistics
+        const statistics = {
+            timespan,
+            totalLines: lines.length,
+            errorCount: errors.length,
+            warningCount: warnings.length,
+            infoCount: allEntries.filter((e) => e.level === "info").length,
+            debugCount: allEntries.filter((e) => e.level === "debug").length,
+            requestCount: requests.length,
+            avgResponseTime,
+            endpoints: endpoints.slice(0, MAX_ENTRIES[options.detail].events),
+            statusCodes,
+        };
+        // Build overview
+        const overview = buildOverview(statistics, timespan);
+        return {
+            logType: "server",
+            overview,
+            errors: deduplicatedErrors.slice(0, MAX_ENTRIES[options.detail].errors),
+            warnings: deduplicatedWarnings.slice(0, MAX_ENTRIES[options.detail].warnings),
+            keyEvents: keyEvents.slice(0, MAX_ENTRIES[options.detail].events),
+            statistics,
+        };
+    },
+};
+/**
+ * Build overview text
+ */
+function buildOverview(stats, timespan) {
+    const parts = [];
+    if (timespan) {
+        parts.push(`Duration: ${timespan.durationFormatted}`);
+    }
+    if (stats.requestCount !== undefined) {
+        parts.push(`${stats.requestCount.toLocaleString()} requests processed`);
+    }
+    if (stats.avgResponseTime !== undefined && stats.avgResponseTime > 0) {
+        parts.push(`avg ${stats.avgResponseTime}ms response time`);
+    }
+    if (stats.errorCount > 0) {
+        parts.push(`${stats.errorCount} errors`);
+    }
+    return parts.join(", ") || "Server log summary";
+}

package/dist/summarizers/test-logs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Test Logs Summarizer
+ *
+ * Summarizes test runner output (Jest, Mocha, Vitest, pytest, etc.).
+ */
+import type { Summarizer } from "./types.js";
+/**
+ * Test logs summarizer
+ */
+export declare const testLogsSummarizer: Summarizer;
+//# sourceMappingURL=test-logs.d.ts.map

package/dist/summarizers/test-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-logs.d.ts","sourceRoot":"","sources":["../../src/summarizers/test-logs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EAMX,MAAM,YAAY,CAAC;AAgJpB;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,UA8HhC,CAAC"}

package/dist/summarizers/test-logs.js

@@ -0,0 +1,258 @@
+/**
+ * Test Logs Summarizer
+ *
+ * Summarizes test runner output (Jest, Mocha, Vitest, pytest, etc.).
+ */
+import { parseLogLine, calculateTimespan, deduplicateEntries, filterByTimeframe, } from "../utils/log-parser.js";
+import { MAX_ENTRIES } from "./types.js";
+/**
+ * Test result patterns for different frameworks
+ */
+const TEST_PATTERNS = {
+    // Jest/Vitest: ✓ test name (5ms) or ✕ test name
+    jest: /^\s*(✓|✕|○)\s+(.+?)(?:\s+\((\d+)\s*m?s\))?$/,
+    // Jest: PASS/FAIL src/file.test.ts
+    jestFile: /^\s*(PASS|FAIL)\s+(.+\.(?:test|spec)\.[jt]sx?)$/,
+    // Mocha: ✓ test name: 5ms or 1) test name
+    mocha: /^\s*(?:(\d+)\)|(✓|✔))\s+(.+?)(?::\s*(\d+)ms)?$/,
+    // pytest: PASSED/FAILED test_file.py::test_name
+    pytest: /^\s*(PASSED|FAILED|SKIPPED|ERROR)\s+(.+?::.+?)(?:\s+\[(\d+)%\])?$/,
+    // Generic: [PASS] or [FAIL]
+    generic: /^\s*\[(PASS|FAIL|SKIP)\]\s+(.+)$/i,
+};
+/**
+ * Summary line patterns
+ */
+const SUMMARY_PATTERNS = {
+    // Jest: Tests: 5 passed, 1 failed, 6 total
+    jest: /Tests?:\s*(\d+)\s*passed?,?\s*(\d+)\s*failed?,?\s*(?:(\d+)\s*skipped?,?\s*)?(\d+)\s*total/i,
+    // Jest: Test Suites: 2 passed, 1 failed, 3 total
+    jestSuites: /Test Suites?:\s*(\d+)\s*passed?,?\s*(\d+)\s*failed?,?\s*(\d+)\s*total/i,
+    // pytest: 5 passed, 1 failed in 2.5s
+    pytest: /(\d+)\s*passed?,?\s*(\d+)\s*failed?(?:,?\s*(\d+)\s*skipped?)?.*?in\s*([\d.]+)s/i,
+    // Time: 5.123s
+    time: /(?:Time|Duration|Ran).*?(\d+(?:\.\d+)?)\s*(?:s|ms|seconds?)/i,
+};
+/**
+ * Parse a test result from a log line
+ */
+function parseTestResult(line) {
+    // Try Jest pattern
+    let match = line.match(TEST_PATTERNS.jest);
+    if (match) {
+        const symbol = match[1];
+        let status = "pass";
+        if (symbol === "✕")
+            status = "fail";
+        else if (symbol === "○")
+            status = "skip";
+        return {
+            name: (match[2] ?? "").trim(),
+            status,
+            duration: match[3] ? parseInt(match[3], 10) : undefined,
+            raw: line,
+        };
+    }
+    // Try Jest file pattern
+    match = line.match(TEST_PATTERNS.jestFile);
+    if (match) {
+        return {
+            name: match[2] ?? "",
+            status: (match[1] ?? "").toLowerCase() === "pass" ? "pass" : "fail",
+            raw: line,
+        };
+    }
+    // Try Mocha pattern
+    match = line.match(TEST_PATTERNS.mocha);
+    if (match) {
+        const isFailNumber = match[1] !== undefined;
+        return {
+            name: (match[3] ?? "").trim(),
+            status: isFailNumber ? "fail" : "pass",
+            duration: match[4] ? parseInt(match[4], 10) : undefined,
+            raw: line,
+        };
+    }
+    // Try pytest pattern
+    match = line.match(TEST_PATTERNS.pytest);
+    if (match) {
+        const statusStr = (match[1] ?? "").toUpperCase();
+        let status = "pass";
+        if (statusStr === "FAILED" || statusStr === "ERROR")
+            status = "fail";
+        else if (statusStr === "SKIPPED")
+            status = "skip";
+        return {
+            name: match[2] ?? "",
+            status,
+            raw: line,
+        };
+    }
+    // Try generic pattern
+    match = line.match(TEST_PATTERNS.generic);
+    if (match) {
+        const statusStr = (match[1] ?? "").toUpperCase();
+        let status = "pass";
+        if (statusStr === "FAIL")
+            status = "fail";
+        else if (statusStr === "SKIP")
+            status = "skip";
+        return {
+            name: (match[2] ?? "").trim(),
+            status,
+            raw: line,
+        };
+    }
+    return null;
+}
+/**
+ * Extract summary statistics from summary lines
+ */
+function extractSummaryStats(logs) {
+    // Try Jest pattern
+    let match = logs.match(SUMMARY_PATTERNS.jest);
+    if (match) {
+        return {
+            passed: parseInt(match[1] ?? "0", 10),
+            failed: parseInt(match[2] ?? "0", 10),
+            skipped: match[3] ? parseInt(match[3], 10) : 0,
+        };
+    }
+    // Try pytest pattern
+    match = logs.match(SUMMARY_PATTERNS.pytest);
+    if (match) {
+        return {
+            passed: parseInt(match[1] ?? "0", 10),
+            failed: parseInt(match[2] ?? "0", 10),
+            skipped: match[3] ? parseInt(match[3], 10) : 0,
+            duration: parseFloat(match[4] ?? "0") * 1000, // Convert to ms
+        };
+    }
+    return null;
+}
+/**
+ * Test logs summarizer
+ */
+export const testLogsSummarizer = {
+    name: "test-logs",
+    logType: "test",
+    canSummarize(logs) {
+        const indicators = [
+            /\b(PASS|FAIL|SKIP)\b/,
+            /\b(describe|it|test)\s*\(/,
+            /✓|✕|○/,
+            /\bTest(?:s|Suites?):/,
+            /\bpytest\b/i,
+            /\b(jest|vitest|mocha)\b/i,
+        ];
+        return indicators.some((p) => p.test(logs));
+    },
+    summarize(logs, options) {
+        const lines = logs.split("\n").filter((l) => l.trim());
+        const testResults = [];
+        const errors = [];
+        const warnings = [];
+        const keyEvents = [];
+        const allEntries = [];
+        // Try to extract summary stats from the logs
+        const summaryStats = extractSummaryStats(logs);
+        // Parse all lines
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Try to parse as test result
+            const testResult = parseTestResult(trimmed);
+            if (testResult) {
+                testResults.push(testResult);
+                if (testResult.status === "fail") {
+                    errors.push({
+                        level: "error",
+                        message: `FAIL: ${testResult.name}`,
+                        count: 1,
+                        raw: trimmed,
+                    });
+                }
+            }
+            // Parse as regular log entry
+            const entry = parseLogLine(trimmed);
+            allEntries.push(entry);
+            // Collect errors from non-test lines
+            if (!testResult && entry.level === "error") {
+                errors.push(entry);
+            }
+            if (entry.level === "warning") {
+                warnings.push(entry);
+            }
+        }
+        // Filter by timeframe if specified
+        const filteredEntries = filterByTimeframe(allEntries, options.timeframe);
+        // Calculate test statistics
+        const passCount = summaryStats?.passed ?? testResults.filter((t) => t.status === "pass").length;
+        const failCount = summaryStats?.failed ?? testResults.filter((t) => t.status === "fail").length;
+        const skipCount = summaryStats?.skipped ?? testResults.filter((t) => t.status === "skip").length;
+        const totalTests = passCount + failCount + skipCount;
+        // Calculate test duration
+        const testDuration = summaryStats?.duration ??
+            testResults.reduce((sum, t) => sum + (t.duration || 0), 0);
+        // Calculate timespan
+        const timespan = calculateTimespan(filteredEntries);
+        // Deduplicate errors
+        const deduplicatedErrors = deduplicateEntries(errors);
+        // Get failed test names
+        const failedTests = testResults
+            .filter((t) => t.status === "fail")
+            .map((t) => ({
+            level: "error",
+            message: t.name,
+            count: 1,
+            raw: t.raw,
+            context: t.error,
+        }));
+        // Build statistics
+        const statistics = {
+            timespan,
+            totalLines: lines.length,
+            errorCount: failCount,
+            warningCount: warnings.length,
+            infoCount: allEntries.filter((e) => e.level === "info").length,
+            debugCount: allEntries.filter((e) => e.level === "debug").length,
+            passCount,
+            failCount,
+            skipCount,
+            testDuration,
+        };
+        // Build overview
+        const overview = buildOverview(statistics, totalTests);
+        // Key events: test file results
+        const fileResults = lines
+            .filter((l) => TEST_PATTERNS.jestFile.test(l))
+            .map((l) => parseLogLine(l));
+        return {
+            logType: "test",
+            overview,
+            errors: failedTests.length > 0 ? failedTests : deduplicatedErrors.slice(0, MAX_ENTRIES[options.detail].errors),
+            warnings: deduplicateEntries(warnings).slice(0, MAX_ENTRIES[options.detail].warnings),
+            keyEvents: fileResults.slice(0, MAX_ENTRIES[options.detail].events),
+            statistics,
+        };
+    },
+};
+/**
+ * Build overview text
+ */
+function buildOverview(stats, totalTests) {
+    const parts = [];
+    if (totalTests > 0) {
+        const passRate = Math.round(((stats.passCount ?? 0) / totalTests) * 100);
+        parts.push(`${totalTests} tests: ${stats.passCount} passed, ${stats.failCount} failed`);
+        if (stats.skipCount && stats.skipCount > 0) {
+            parts.push(`${stats.skipCount} skipped`);
+        }
+        parts.push(`(${passRate}% pass rate)`);
+    }
+    if (stats.testDuration && stats.testDuration > 0) {
+        parts.push(`in ${(stats.testDuration / 1000).toFixed(2)}s`);
+    }
+    return parts.join(" ") || "Test log summary";
+}

package/dist/summarizers/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Log Summarizer Types
+ *
+ * Common types and interfaces for log summarization.
+ */
+export type LogType = "server" | "test" | "build" | "application" | "generic";
+export type FocusArea = "errors" | "warnings" | "performance" | "timeline";
+export type DetailLevel = "minimal" | "normal" | "detailed";
+export type LogLevel = "error" | "warning" | "info" | "debug";
+/**
+ * A single parsed log entry
+ */
+export interface LogEntry {
+    /** Timestamp if present */
+    timestamp?: string;
+    /** Log level */
+    level: LogLevel;
+    /** Main message content */
+    message: string;
+    /** Number of occurrences if deduplicated */
+    count: number;
+    /** Additional context (stack trace, etc.) */
+    context?: string;
+    /** Original raw line */
+    raw: string;
+}
+/**
+ * HTTP request entry for server logs
+ */
+export interface HttpRequestEntry {
+    timestamp?: string;
+    method: string;
+    path: string;
+    statusCode: number;
+    responseTime?: number;
+    raw: string;
+}
+/**
+ * Test result entry for test logs
+ */
+export interface TestResultEntry {
+    name: string;
+    status: "pass" | "fail" | "skip" | "pending";
+    duration?: number;
+    error?: string;
+    raw: string;
+}
+/**
+ * Timespan information
+ */
+export interface Timespan {
+    start: string;
+    end: string;
+    durationMs: number;
+    durationFormatted: string;
+}
+/**
+ * Statistics extracted from logs
+ */
+export interface LogStatistics {
+    /** Time range of logs */
+    timespan?: Timespan;
+    /** Total lines processed */
+    totalLines: number;
+    /** Count by log level */
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    debugCount: number;
+    requestCount?: number;
+    avgResponseTime?: number;
+    endpoints?: Array<{
+        method: string;
+        path: string;
+        count: number;
+        avgTime: number;
+        errorCount: number;
+    }>;
+    statusCodes?: Map<number, number>;
+    passCount?: number;
+    failCount?: number;
+    skipCount?: number;
+    testDuration?: number;
+    buildDuration?: number;
+    compiledFiles?: number;
+    bundleSize?: number;
+}
+/**
+ * Complete log summary result
+ */
+export interface LogSummary {
+    /** Type of log detected/specified */
+    logType: LogType;
+    /** Brief overview text */
+    overview: string;
+    /** Error entries (deduplicated) */
+    errors: LogEntry[];
+    /** Warning entries (deduplicated) */
+    warnings: LogEntry[];
+    /** Key events timeline */
+    keyEvents: LogEntry[];
+    /** Computed statistics */
+    statistics: LogStatistics;
+}
+/**
+ * Options for summarization
+ */
+export interface SummarizeOptions {
+    /** Type of log (auto-detected if not provided) */
+    logType?: LogType;
+    /** Areas to focus on */
+    focus?: FocusArea[];
+    /** Level of detail */
+    detail: DetailLevel;
+    /** Time range filter */
+    timeframe?: {
+        start?: string;
+        end?: string;
+    };
+}
+/**
+ * Summarizer interface for different log types
+ */
+export interface Summarizer {
+    /** Summarizer name */
+    name: string;
+    /** Log type this summarizer handles */
+    logType: LogType;
+    /** Check if this summarizer can handle the given logs */
+    canSummarize(logs: string): boolean;
+    /** Generate summary from logs */
+    summarize(logs: string, options: SummarizeOptions): LogSummary;
+}
+/**
+ * Detail level thresholds
+ */
+export declare const DETAIL_THRESHOLDS: Record<DetailLevel, number>;
+/**
+ * Maximum entries per section by detail level
+ */
+export declare const MAX_ENTRIES: Record<DetailLevel, {
+    errors: number;
+    warnings: number;
+    events: number;
+}>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/summarizers/types.ts"],"names":[],"mappings":"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"}

package/dist/summarizers/types.js

@@ -0,0 +1,21 @@
+/**
+ * Log Summarizer Types
+ *
+ * Common types and interfaces for log summarization.
+ */
+/**
+ * Detail level thresholds
+ */
+export const DETAIL_THRESHOLDS = {
+    minimal: 3,
+    normal: 5,
+    detailed: 10,
+};
+/**
+ * Maximum entries per section by detail level
+ */
+export const MAX_ENTRIES = {
+    minimal: { errors: 5, warnings: 3, events: 5 },
+    normal: { errors: 10, warnings: 5, events: 10 },
+    detailed: { errors: 20, warnings: 10, events: 20 },
+};

package/dist/tools/analyze-build-output.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Analyze Build Output Tool
+ *
+ * Analyzes and compresses build tool outputs (tsc, webpack, eslint, etc.)
+ * to dramatically reduce tokens while preserving critical information.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const analyzeBuildOutputSchema: {
+    type: "object";
+    properties: {
+        output: {
+            type: string;
+        };
+        buildTool: {
+            enum: string[];
+        };
+        verbosity: {
+            enum: string[];
+        };
+    };
+    required: string[];
+};
+export declare function executeAnalyzeBuildOutput(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const analyzeBuildOutputTool: ToolDefinition;
+//# sourceMappingURL=analyze-build-output.d.ts.map