distill-mcp 0.6.0-beta

package/dist/tools/code-skeleton.js

@@ -0,0 +1,206 @@
+/**
+ * Code Skeleton Tool
+ *
+ * Extracts code skeleton (signatures only) from source files.
+ * Provides configurable depth levels and token statistics.
+ */
+import { z } from "zod";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { parseFile, hasParserSupport } from "../ast/index.js";
+import { detectLanguageFromPath } from "../utils/language-detector.js";
+import { countTokens } from "../utils/token-counter.js";
+// Minimal schema - includeTypes/includeComments rarely changed
+export const codeSkeletonSchema = {
+    type: "object",
+    properties: {
+        filePath: { type: "string" },
+        depth: { enum: [1, 2, 3] },
+    },
+    required: ["filePath"],
+};
+// Schema Zod
+const inputSchema = z.object({
+    filePath: z.string(),
+    includeTypes: z.boolean().optional().default(true),
+    includeComments: z.boolean().optional().default(true),
+    depth: z.number().min(1).max(3).optional().default(1),
+});
+/**
+ * Format file structure as skeleton based on depth level
+ *
+ * Depth levels:
+ * - 1: Signatures only (minimal)
+ * - 2: Signatures + inline doc preview
+ * - 3: Full signatures with complete docs
+ */
+function formatSkeletonByDepth(structure, depth, includeTypes, includeComments, language) {
+    const lines = [];
+    // Types/Interfaces (if includeTypes)
+    if (includeTypes && structure.types?.length) {
+        for (const t of structure.types) {
+            const exported = t.isExported ? "export " : "";
+            if (depth >= 2 && includeComments && t.documentation) {
+                const doc = t.documentation.split("\n")[0];
+                if (depth === 3) {
+                    lines.push(`/** ${t.documentation} */`);
+                }
+                else {
+                    lines.push(`/** ${doc} */`);
+                }
+            }
+            lines.push(`${exported}${t.signature || `type ${t.name}`}`);
+        }
+        if (structure.types.length > 0)
+            lines.push("");
+    }
+    // Functions (top-level only, not methods)
+    const topLevelFunctions = structure.functions?.filter((f) => !f.parent) || [];
+    if (topLevelFunctions.length > 0) {
+        for (const fn of topLevelFunctions) {
+            const exported = fn.isExported ? "export " : "";
+            const asyncMod = fn.isAsync ? "async " : "";
+            const sig = fn.signature || `function ${fn.name}()`;
+            if (depth === 1) {
+                lines.push(`${exported}${asyncMod}${sig}`);
+            }
+            else if (depth >= 2) {
+                if (includeComments && fn.documentation) {
+                    const doc = fn.documentation.split("\n")[0];
+                    if (depth === 3) {
+                        lines.push(`/** ${fn.documentation} */`);
+                        lines.push(`${exported}${asyncMod}${sig}`);
+                    }
+                    else {
+                        lines.push(`${exported}${asyncMod}${sig} // ${doc}`);
+                    }
+                }
+                else {
+                    lines.push(`${exported}${asyncMod}${sig}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    // Classes with methods
+    if (structure.classes?.length) {
+        for (const cls of structure.classes) {
+            const exported = cls.isExported ? "export " : "";
+            if (depth >= 2 && includeComments && cls.documentation) {
+                const doc = cls.documentation.split("\n")[0];
+                if (depth === 3) {
+                    lines.push(`/** ${cls.documentation} */`);
+                }
+                else {
+                    lines.push(`/** ${doc} */`);
+                }
+            }
+            lines.push(`${exported}class ${cls.name} {`);
+            // Methods
+            const methods = structure.functions?.filter((f) => f.parent === cls.name) || [];
+            for (const m of methods) {
+                const asyncMod = m.isAsync ? "async " : "";
+                const sig = m.signature || `${m.name}()`;
+                if (depth === 1) {
+                    lines.push(`  ${asyncMod}${sig}`);
+                }
+                else if (depth >= 2) {
+                    if (includeComments && m.documentation) {
+                        const doc = m.documentation.split("\n")[0];
+                        if (depth === 3) {
+                            lines.push(`  /** ${m.documentation} */`);
+                            lines.push(`  ${asyncMod}${sig}`);
+                        }
+                        else {
+                            lines.push(`  ${asyncMod}${sig} // ${doc}`);
+                        }
+                    }
+                    else {
+                        lines.push(`  ${asyncMod}${sig}`);
+                    }
+                }
+            }
+            lines.push(`}`);
+            lines.push("");
+        }
+    }
+    // Exported variables (constants, etc.)
+    const exportedVars = structure.variables?.filter((v) => v.isExported) || [];
+    if (exportedVars.length > 0) {
+        for (const v of exportedVars) {
+            if (depth >= 2 && includeComments && v.documentation) {
+                const doc = v.documentation.split("\n")[0];
+                lines.push(`// ${doc}`);
+            }
+            lines.push(`export ${v.signature || `const ${v.name}`}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+/**
+ * Execute code-skeleton tool
+ */
+export async function executeCodeSkeleton(args) {
+    const input = inputSchema.parse(args);
+    const workingDir = process.cwd();
+    // Resolve path
+    const resolvedPath = path.isAbsolute(input.filePath)
+        ? path.normalize(input.filePath)
+        : path.resolve(workingDir, input.filePath);
+    // Read file
+    let content;
+    try {
+        content = await fs.readFile(resolvedPath, "utf-8");
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `File not found: ${resolvedPath}` }],
+        };
+    }
+    // Detect language
+    const language = detectLanguageFromPath(resolvedPath);
+    if (!hasParserSupport(language)) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Language '${language}' not supported for skeleton extraction. Supported: typescript, javascript, python, go, rust, php, swift`,
+                },
+            ],
+        };
+    }
+    // Parse file
+    const structure = parseFile(content, language);
+    // Generate skeleton
+    const skeleton = formatSkeletonByDepth(structure, input.depth, input.includeTypes, input.includeComments, language);
+    // Calculate statistics
+    const originalTokens = countTokens(content);
+    const skeletonTokens = countTokens(skeleton);
+    const savings = originalTokens > 0
+        ? Math.round((1 - skeletonTokens / originalTokens) * 100)
+        : 0;
+    // Format output
+    const depthLabels = ["", "signatures", "signatures+docs", "full"];
+    const output = [
+        `## Code Skeleton: ${input.filePath}`,
+        "",
+        `**Language:** ${language} | **Depth:** ${input.depth} (${depthLabels[input.depth]})`,
+        `**Options:** types=${input.includeTypes}, comments=${input.includeComments}`,
+        `**Tokens:** ${skeletonTokens} (was ${originalTokens}) | **Savings:** ${savings}%`,
+        "",
+        "```" + language,
+        skeleton,
+        "```",
+    ].join("\n");
+    return { content: [{ type: "text", text: output }] };
+}
+/**
+ * Code Skeleton Tool Definition
+ */
+export const codeSkeletonTool = {
+    name: "code_skeleton",
+    description: "Extract signatures only (no bodies). Depth: 1=minimal, 2=+docs, 3=full.",
+    inputSchema: codeSkeletonSchema,
+    execute: executeCodeSkeleton,
+};

package/dist/tools/compress-context.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Compress Context Tool
+ *
+ * Compresses verbose text content (logs, stack traces, configs)
+ * while preserving essential information.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const compressContextSchema: {
+    type: "object";
+    properties: {
+        content: {
+            type: string;
+        };
+        contentType: {
+            enum: string[];
+        };
+        targetRatio: {
+            type: string;
+        };
+        detail: {
+            enum: string[];
+        };
+    };
+    required: string[];
+};
+export declare function executeCompressContext(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const compressContextTool: ToolDefinition;
+//# sourceMappingURL=compress-context.d.ts.map

package/dist/tools/compress-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-context.d.ts","sourceRoot":"","sources":["../../src/tools/compress-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;CASjC,CAAC;AA+BF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAkC7D;AAED,eAAO,MAAM,mBAAmB,EAAE,cAKjC,CAAC"}

package/dist/tools/compress-context.js

@@ -0,0 +1,64 @@
+/**
+ * Compress Context Tool
+ *
+ * Compresses verbose text content (logs, stack traces, configs)
+ * while preserving essential information.
+ */
+import { z } from "zod";
+import { compressContent, analyzeContent } from "../compressors/index.js";
+// Minimal schema - preservePatterns rarely used
+export const compressContextSchema = {
+    type: "object",
+    properties: {
+        content: { type: "string" },
+        contentType: { enum: ["logs", "stacktrace", "config", "code", "generic"] },
+        targetRatio: { type: "number" },
+        detail: { enum: ["minimal", "normal", "detailed"] },
+    },
+    required: ["content"],
+};
+const inputSchema = z.object({
+    content: z.string(),
+    contentType: z.enum(["logs", "stacktrace", "config", "code", "generic"]).optional(),
+    targetRatio: z.number().min(0.01).max(1).optional(),
+    preservePatterns: z.array(z.string()).optional(),
+    detail: z.enum(["minimal", "normal", "detailed"]).optional().default("normal"),
+});
+/**
+ * Format compression result as markdown
+ */
+function formatResult(compressed, stats, contentType, _omittedInfo) {
+    // Minimal header to save tokens
+    const header = `[${contentType}] ${stats.originalTokens}→${stats.compressedTokens} tokens (-${stats.reductionPercent}%)`;
+    return `${header}\n${compressed}`;
+}
+export async function executeCompressContext(args) {
+    const input = inputSchema.parse(args);
+    // Convert preserve patterns to RegExp
+    const preservePatterns = input.preservePatterns?.map((p) => new RegExp(p));
+    // Analyze content if type not provided
+    const analysis = analyzeContent(input.content);
+    const contentType = (input.contentType ?? analysis.detectedType);
+    // Compress
+    const result = compressContent(input.content, {
+        contentType,
+        detail: input.detail,
+        targetRatio: input.targetRatio,
+        preservePatterns,
+    });
+    // Update session state with token savings
+    const tokensSaved = result.stats.originalTokens - result.stats.compressedTokens;
+    if (tokensSaved > 0) {
+    }
+    // Format output
+    const formatted = formatResult(result.compressed, result.stats, contentType, result.omittedInfo);
+    return {
+        content: [{ type: "text", text: formatted }],
+    };
+}
+export const compressContextTool = {
+    name: "compress_context",
+    description: "Compress verbose text (logs, stack traces, configs). 40-90% reduction.",
+    inputSchema: compressContextSchema,
+    execute: executeCompressContext,
+};

package/dist/tools/context-budget.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Context Budget Tool
+ *
+ * Proactive token budget management - analyze content BEFORE sending to LLM
+ * to estimate costs, check budget constraints, and get optimization recommendations.
+ */
+import type { ToolDefinition } from "./registry.js";
+/**
+ * JSON Schema for MCP tool registration
+ */
+export declare const contextBudgetSchema: {
+    type: "object";
+    properties: {
+        content: {
+            type: string;
+        };
+        model: {
+            enum: string[];
+        };
+        budgetTokens: {
+            type: string;
+        };
+        includeEstimatedOutput: {
+            type: string;
+        };
+    };
+    required: string[];
+};
+/**
+ * Execute the context-budget tool
+ */
+export declare function executeContextBudget(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+/**
+ * Tool definition for MCP registration
+ */
+export declare const contextBudgetTool: ToolDefinition;
+//# sourceMappingURL=context-budget.d.ts.map

package/dist/tools/context-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-budget.d.ts","sourceRoot":"","sources":["../../src/tools/context-budget.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAapD;;GAEG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;CAS/B,CAAC;AAwPF;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,CAqFD;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAK/B,CAAC"}

package/dist/tools/context-budget.js

@@ -0,0 +1,260 @@
+/**
+ * Context Budget Tool
+ *
+ * Proactive token budget management - analyze content BEFORE sending to LLM
+ * to estimate costs, check budget constraints, and get optimization recommendations.
+ */
+import { z } from "zod";
+import { countTokens } from "../utils/token-counter.js";
+import { detectContentType } from "../utils/content-detector.js";
+import { estimateOutputTokens } from "../utils/output-estimator.js";
+import { ANTHROPIC_MODELS, DEFAULT_MODEL, calculateCost, formatCost, calculateContextUsage, } from "@ctxopt/shared";
+/**
+ * JSON Schema for MCP tool registration
+ */
+// Minimal schema
+export const contextBudgetSchema = {
+    type: "object",
+    properties: {
+        content: { type: "string" },
+        model: { enum: ["claude-opus-4-20250514", "claude-sonnet-4-20250514", "claude-3-5-haiku-20241022"] },
+        budgetTokens: { type: "number" },
+        includeEstimatedOutput: { type: "boolean" },
+    },
+    required: ["content"],
+};
+/**
+ * Zod schema for runtime validation
+ */
+const inputSchema = z.object({
+    content: z.string().min(1, "Content is required"),
+    model: z
+        .enum([
+        "claude-opus-4-20250514",
+        "claude-sonnet-4-20250514",
+        "claude-3-5-haiku-20241022",
+    ])
+        .optional()
+        .default(DEFAULT_MODEL),
+    budgetTokens: z.number().min(50).optional(),
+    includeEstimatedOutput: z.boolean().optional().default(true),
+});
+/**
+ * Analyze content for optimization opportunities
+ */
+function analyzeContent(content, tokenCount) {
+    const lines = content.split("\n");
+    const nonEmptyLines = lines.filter((l) => l.trim().length > 0);
+    const uniqueLines = new Set(nonEmptyLines);
+    const duplicateRatio = nonEmptyLines.length > 0
+        ? 1 - uniqueLines.size / nonEmptyLines.length
+        : 0;
+    return {
+        hasCode: /```|\bfunction\b|\bclass\b|\bconst\b|\blet\b|\bvar\b|\bimport\b|\bexport\b|def\s+\w+|func\s+\w+|fn\s+\w+/.test(content),
+        hasLogs: /\[(INFO|DEBUG|WARN|ERROR|FATAL|TRACE)\]|\b(INFO|DEBUG|WARN|ERROR|FATAL)\b:|\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(content),
+        hasErrors: /\b(error|exception|failed|failure|stack\s*trace|traceback|panic)\b/i.test(content) || /at\s+\w+\s*\(/.test(content),
+        hasDuplicates: duplicateRatio > 0.2, // >20% duplicates
+        isLongProse: tokenCount > 2000 && !/```/.test(content),
+        tokenCount,
+    };
+}
+/**
+ * Generate optimization recommendations based on content analysis
+ */
+function generateRecommendations(analysis) {
+    const recommendations = [];
+    // Rule 1: Code content -> smart_file_read
+    if (analysis.hasCode && analysis.tokenCount > 500) {
+        recommendations.push({
+            action: "Extract only relevant code sections",
+            tool: "smart_file_read",
+            expectedSavings: 60,
+            description: "Use smart_file_read to extract specific functions/classes instead of full file content. Typical savings: 50-70%.",
+        });
+    }
+    // Rule 2: Logs -> summarize_logs
+    if (analysis.hasLogs) {
+        recommendations.push({
+            action: "Summarize log output",
+            tool: "summarize_logs",
+            expectedSavings: 85,
+            description: "Use summarize_logs to extract key events, errors, and patterns. Typical savings: 80-90%.",
+        });
+    }
+    // Rule 3: Errors + duplicates -> deduplicate_errors
+    if (analysis.hasErrors && analysis.hasDuplicates) {
+        recommendations.push({
+            action: "Deduplicate repeated errors",
+            tool: "deduplicate_errors",
+            expectedSavings: 80,
+            description: "Use deduplicate_errors to group identical error messages. Typical savings: 80-95%.",
+        });
+    }
+    else if (analysis.hasErrors) {
+        // Rule 4: Errors alone -> auto_optimize
+        recommendations.push({
+            action: "Compress error output",
+            tool: "auto_optimize",
+            expectedSavings: 70,
+            description: "Use auto_optimize to intelligently compress error output. Typical savings: 60-90%.",
+        });
+    }
+    // Rule 5: Long prose -> semantic_compress
+    if (analysis.isLongProse) {
+        recommendations.push({
+            action: "Apply semantic compression",
+            tool: "semantic_compress",
+            expectedSavings: 50,
+            description: "Use semantic_compress to preserve key information while reducing verbosity. Typical savings: 40-60%.",
+        });
+    }
+    // Rule 6: Duplicates without errors -> compress_context
+    if (analysis.hasDuplicates && !analysis.hasErrors) {
+        recommendations.push({
+            action: "Remove redundant content",
+            tool: "compress_context",
+            expectedSavings: 45,
+            description: "Use compress_context to eliminate duplicate lines and normalize whitespace. Typical savings: 40-60%.",
+        });
+    }
+    // Rule 7: Large generic content -> auto_optimize (fallback)
+    if (analysis.tokenCount > 3000 && recommendations.length === 0) {
+        recommendations.push({
+            action: "Auto-optimize content",
+            tool: "auto_optimize",
+            expectedSavings: 50,
+            description: "Use auto_optimize to automatically detect content type and apply best compression strategy.",
+        });
+    }
+    return recommendations;
+}
+/**
+ * Format the analysis result as markdown
+ */
+function formatOutput(result, model) {
+    const modelInfo = ANTHROPIC_MODELS[model];
+    const modelName = modelInfo?.name || model;
+    const parts = [];
+    parts.push("## Context Budget Analysis\n");
+    // Token summary table
+    parts.push("### Token Estimate\n");
+    parts.push("| Metric | Value |");
+    parts.push("|--------|-------|");
+    parts.push(`| Input Tokens | ${result.inputTokens.toLocaleString()} |`);
+    parts.push(`| Estimated Output | ${result.estimatedOutputTokens.toLocaleString()} |`);
+    parts.push(`| **Total Estimated** | **${result.totalEstimatedTokens.toLocaleString()}** |`);
+    parts.push(`| Estimated Cost | ${formatCost(result.estimatedCostUSD * 1_000_000)} |`);
+    parts.push(`| Context Usage | ${result.contextUsagePercent}% |`);
+    parts.push(`| Model | ${modelName} |\n`);
+    // Budget status
+    if (result.budgetRemaining !== null) {
+        const withinBudget = result.withinBudget;
+        const status = withinBudget ? "Within Budget" : "**OVER BUDGET**";
+        const icon = withinBudget ? "" : "";
+        const remaining = withinBudget
+            ? `${result.budgetRemaining.toLocaleString()} tokens remaining`
+            : `${Math.abs(result.budgetRemaining).toLocaleString()} tokens over limit`;
+        parts.push(`### Budget Status: ${icon} ${status}`);
+        parts.push(`${remaining}\n`);
+    }
+    // Recommendations
+    if (result.recommendations.length > 0) {
+        parts.push("### Optimization Recommendations\n");
+        for (const rec of result.recommendations) {
+            parts.push(`**${rec.action}** (~${rec.expectedSavings}% savings)`);
+            parts.push(`- Tool: \`${rec.tool}\``);
+            parts.push(`- ${rec.description}\n`);
+        }
+        parts.push(`**Potential Savings:** Up to ${result.potentialSavingsPercent}% reduction possible\n`);
+    }
+    else {
+        parts.push("### Status\n");
+        parts.push("Content is already well-optimized. No immediate recommendations.\n");
+    }
+    // Quick action hint
+    if (result.autoOptimizeAvailable) {
+        parts.push("---");
+        parts.push("*Tip: Use `auto_optimize` to automatically apply the best compression strategy.*");
+    }
+    return parts.join("\n");
+}
+/**
+ * Execute the context-budget tool
+ */
+export async function executeContextBudget(args) {
+    // Validate input
+    const parseResult = inputSchema.safeParse(args);
+    if (!parseResult.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Invalid input: ${parseResult.error.errors.map((e) => e.message).join(", ")}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const { content, model, budgetTokens, includeEstimatedOutput } = parseResult.data;
+    // Count input tokens
+    const inputTokens = countTokens(content);
+    // Detect content type
+    const contentType = detectContentType(content);
+    // Analyze content for recommendations
+    const analysis = analyzeContent(content, inputTokens);
+    // Estimate output tokens
+    const outputEstimate = includeEstimatedOutput
+        ? estimateOutputTokens(content, inputTokens, contentType)
+        : { estimated: 0, confidence: "high", reasoning: "Disabled" };
+    const estimatedOutputTokens = outputEstimate.estimated;
+    const totalEstimatedTokens = inputTokens + estimatedOutputTokens;
+    // Calculate cost
+    const costs = calculateCost(model, inputTokens, estimatedOutputTokens);
+    const estimatedCostUSD = costs.totalCostMicros / 1_000_000;
+    // Calculate context usage
+    const contextUsagePercent = calculateContextUsage(totalEstimatedTokens, model);
+    // Budget check
+    const withinBudget = budgetTokens
+        ? totalEstimatedTokens <= budgetTokens
+        : true;
+    const budgetRemaining = budgetTokens
+        ? budgetTokens - totalEstimatedTokens
+        : null;
+    // Generate recommendations
+    const recommendations = generateRecommendations(analysis);
+    // Calculate potential savings (max of all recommendations)
+    const potentialSavingsPercent = recommendations.length > 0
+        ? Math.min(95, Math.max(...recommendations.map((r) => r.expectedSavings)))
+        : 0;
+    // Determine if auto_optimize can help
+    const autoOptimizeAvailable = inputTokens > 500 &&
+        (analysis.hasLogs ||
+            analysis.hasErrors ||
+            analysis.hasDuplicates ||
+            analysis.isLongProse);
+    const result = {
+        inputTokens,
+        estimatedOutputTokens,
+        totalEstimatedTokens,
+        estimatedCostUSD,
+        contextUsagePercent,
+        withinBudget,
+        budgetRemaining,
+        recommendations,
+        autoOptimizeAvailable,
+        potentialSavingsPercent,
+    };
+    const formatted = formatOutput(result, model);
+    return {
+        content: [{ type: "text", text: formatted }],
+    };
+}
+/**
+ * Tool definition for MCP registration
+ */
+export const contextBudgetTool = {
+    name: "context_budget",
+    description: "Pre-flight token/cost estimation with optimization recommendations.",
+    inputSchema: contextBudgetSchema,
+    execute: executeContextBudget,
+};

package/dist/tools/context-budget.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Context Budget Tool Tests
+ */
+export {};
+//# sourceMappingURL=context-budget.test.d.ts.map

package/dist/tools/context-budget.test.d.ts.map

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