distill-mcp 0.6.0-beta

package/bin/cli.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { runServer } from "../dist/server.js";
+import { setup, parseSetupArgs } from "../dist/cli/setup.js";
+import { doctor } from "../dist/cli/doctor.js";
+import { runAnalyze } from "../dist/cli/analyze.js";
+import { getPackageVersion, COLORS, log } from "../dist/cli/utils.js";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function showHelp() {
+  const version = getPackageVersion();
+  console.log(`
+${COLORS.bright}${COLORS.cyan}CtxOpt MCP Server${COLORS.reset} v${version}
+Context Engineering Optimizer for Claude Code, Cursor, and Windsurf
+
+${COLORS.bright}Usage:${COLORS.reset}
+  ctxopt-mcp <command> [options]
+
+${COLORS.bright}Commands:${COLORS.reset}
+  serve             Start the MCP server (stdio mode)
+  setup             Configure IDEs to use CtxOpt
+  doctor            Check installation and configuration
+  analyze           Analyze files for token usage
+
+${COLORS.bright}Setup Options:${COLORS.reset}
+  --claude          Configure Claude Code only
+  --cursor          Configure Cursor only
+  --windsurf        Configure Windsurf only
+  --hooks           Install project hooks (enforces MCP tool usage)
+  --force, -f       Overwrite existing configuration
+
+${COLORS.bright}Server Options:${COLORS.reset}
+  --lazy            Enable lazy mode (95% token savings, only 2 meta-tools)
+  --mode <mode>     Loading mode: lazy|core|all (default: core)
+  --verbose         Enable verbose logging (shows tool calls, timing, tokens)
+
+${COLORS.bright}Analyze Options:${COLORS.reset}
+  --patterns, -p    Glob patterns to match (default: **/*.{ts,tsx,js,jsx,py,go,rs})
+  --threshold, -t   Token threshold for warnings (default: 2000)
+  --json, -j        Output as JSON
+  --output, -o      Write report to file
+
+${COLORS.bright}Other Options:${COLORS.reset}
+  --version, -v     Show version number
+  --help, -h        Show this help message
+
+${COLORS.bright}Examples:${COLORS.reset}
+  ctxopt-mcp setup                    Auto-detect and configure all IDEs
+  ctxopt-mcp setup --claude           Configure Claude Code only
+  ctxopt-mcp setup --claude --hooks   Configure Claude Code + install hooks
+  ctxopt-mcp setup --hooks            Install hooks only (current project)
+  ctxopt-mcp setup --force            Overwrite existing configurations
+  ctxopt-mcp doctor                   Verify installation
+  ctxopt-mcp serve                    Start MCP server (used by IDE)
+  ctxopt-mcp serve --lazy             Start with lazy mode (95% savings)
+  ctxopt-mcp serve --verbose          Start with verbose logging
+  ctxopt-mcp analyze                  Analyze token usage in codebase
+  ctxopt-mcp analyze -t 5000 --json   Custom threshold, JSON output
+
+${COLORS.bright}Documentation:${COLORS.reset}
+  https://ctxopt.dev/docs
+`);
+}
+
+function showVersion() {
+  console.log(getPackageVersion());
+}
+
+async function main() {
+  // Handle version flag anywhere
+  if (args.includes("--version") || args.includes("-v")) {
+    showVersion();
+    process.exit(0);
+  }
+
+  // Handle help flag anywhere
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    showHelp();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case "serve": {
+      // Parse mode option
+      let mode = "core";
+      const modeIndex = args.indexOf("--mode");
+      if (modeIndex !== -1 && args[modeIndex + 1]) {
+        mode = args[modeIndex + 1];
+      } else if (args.includes("--lazy")) {
+        mode = "lazy";
+      } else if (args.includes("--all")) {
+        mode = "all";
+      }
+
+      const config = {
+        verbose: args.includes("--verbose"),
+        mode,
+      };
+
+      await runServer(config);
+      break;
+    }
+
+    case "setup": {
+      const options = parseSetupArgs(args.slice(1));
+      await setup(options);
+      break;
+    }
+
+    case "doctor": {
+      await doctor();
+      break;
+    }
+
+    case "analyze": {
+      await runAnalyze(args.slice(1));
+      break;
+    }
+
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.error('Run "ctxopt-mcp --help" for usage information.');
+      process.exit(1);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});

package/dist/analytics/session-tracker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Session Tracker
+ *
+ * Singleton class that tracks per-session statistics for tool usage,
+ * token savings, and optimization metrics.
+ */
+/**
+ * Per-tool statistics
+ */
+export interface ToolStats {
+    invocations: number;
+    tokensIn: number;
+    tokensOut: number;
+    tokensSaved: number;
+    totalDurationMs: number;
+    errors: number;
+}
+/**
+ * Session-wide statistics
+ */
+export interface SessionStats {
+    startTime: Date;
+    lastActivityTime: Date;
+    totalInvocations: number;
+    totalTokensIn: number;
+    totalTokensOut: number;
+    totalTokensSaved: number;
+    totalDurationMs: number;
+    totalErrors: number;
+    toolStats: Record<string, ToolStats>;
+}
+/**
+ * Session Tracker class
+ * Accumulates statistics across all tool invocations in a session.
+ */
+declare class SessionTracker {
+    private startTime;
+    private lastActivityTime;
+    private toolStats;
+    constructor();
+    /**
+     * Record a tool invocation
+     */
+    recordInvocation(toolName: string, tokensIn: number, tokensOut: number, tokensSaved: number, durationMs: number, isError?: boolean): void;
+    /**
+     * Get current session statistics
+     */
+    getStats(): SessionStats;
+    /**
+     * Reset session statistics
+     */
+    reset(): void;
+    /**
+     * Get session duration in milliseconds
+     */
+    getSessionDurationMs(): number;
+    /**
+     * Get optimization rate (tokens saved / tokens in)
+     */
+    getOptimizationRate(): number;
+}
+/**
+ * Get the global session tracker instance
+ */
+export declare function getSessionTracker(): SessionTracker;
+/**
+ * Reset the global session tracker
+ */
+export declare function resetSessionTracker(): void;
+/**
+ * Export session stats for the session tracker
+ */
+export { SessionTracker };
+//# sourceMappingURL=session-tracker.d.ts.map

package/dist/analytics/session-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tracker.d.ts","sourceRoot":"","sources":["../../src/analytics/session-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,IAAI,CAAC;IAChB,gBAAgB,EAAE,IAAI,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACtC;AAED;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,SAAS,CAAO;IACxB,OAAO,CAAC,gBAAgB,CAAO;IAC/B,OAAO,CAAC,SAAS,CAAyB;;IAQ1C;;OAEG;IACH,gBAAgB,CACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,OAAe,GACvB,IAAI;IAsBP;;OAEG;IACH,QAAQ,IAAI,YAAY;IAiCxB;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,mBAAmB,IAAI,MAAM;CAK9B;AAKD;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAKlD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C;AAED;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/analytics/session-tracker.js

@@ -0,0 +1,123 @@
+/**
+ * Session Tracker
+ *
+ * Singleton class that tracks per-session statistics for tool usage,
+ * token savings, and optimization metrics.
+ */
+/**
+ * Session Tracker class
+ * Accumulates statistics across all tool invocations in a session.
+ */
+class SessionTracker {
+    startTime;
+    lastActivityTime;
+    toolStats;
+    constructor() {
+        this.startTime = new Date();
+        this.lastActivityTime = new Date();
+        this.toolStats = new Map();
+    }
+    /**
+     * Record a tool invocation
+     */
+    recordInvocation(toolName, tokensIn, tokensOut, tokensSaved, durationMs, isError = false) {
+        this.lastActivityTime = new Date();
+        const existing = this.toolStats.get(toolName) || {
+            invocations: 0,
+            tokensIn: 0,
+            tokensOut: 0,
+            tokensSaved: 0,
+            totalDurationMs: 0,
+            errors: 0,
+        };
+        existing.invocations++;
+        existing.tokensIn += tokensIn;
+        existing.tokensOut += tokensOut;
+        existing.tokensSaved += tokensSaved;
+        existing.totalDurationMs += durationMs;
+        if (isError)
+            existing.errors++;
+        this.toolStats.set(toolName, existing);
+    }
+    /**
+     * Get current session statistics
+     */
+    getStats() {
+        let totalInvocations = 0;
+        let totalTokensIn = 0;
+        let totalTokensOut = 0;
+        let totalTokensSaved = 0;
+        let totalDurationMs = 0;
+        let totalErrors = 0;
+        const toolStatsObj = {};
+        for (const [name, stats] of this.toolStats.entries()) {
+            totalInvocations += stats.invocations;
+            totalTokensIn += stats.tokensIn;
+            totalTokensOut += stats.tokensOut;
+            totalTokensSaved += stats.tokensSaved;
+            totalDurationMs += stats.totalDurationMs;
+            totalErrors += stats.errors;
+            toolStatsObj[name] = { ...stats };
+        }
+        return {
+            startTime: this.startTime,
+            lastActivityTime: this.lastActivityTime,
+            totalInvocations,
+            totalTokensIn,
+            totalTokensOut,
+            totalTokensSaved,
+            totalDurationMs,
+            totalErrors,
+            toolStats: toolStatsObj,
+        };
+    }
+    /**
+     * Reset session statistics
+     */
+    reset() {
+        this.startTime = new Date();
+        this.lastActivityTime = new Date();
+        this.toolStats.clear();
+    }
+    /**
+     * Get session duration in milliseconds
+     */
+    getSessionDurationMs() {
+        return Date.now() - this.startTime.getTime();
+    }
+    /**
+     * Get optimization rate (tokens saved / tokens in)
+     */
+    getOptimizationRate() {
+        const stats = this.getStats();
+        if (stats.totalTokensIn === 0)
+            return 0;
+        return stats.totalTokensSaved / stats.totalTokensIn;
+    }
+}
+// Global singleton instance
+let globalTracker = null;
+/**
+ * Get the global session tracker instance
+ */
+export function getSessionTracker() {
+    if (!globalTracker) {
+        globalTracker = new SessionTracker();
+    }
+    return globalTracker;
+}
+/**
+ * Reset the global session tracker
+ */
+export function resetSessionTracker() {
+    if (globalTracker) {
+        globalTracker.reset();
+    }
+    else {
+        globalTracker = new SessionTracker();
+    }
+}
+/**
+ * Export session stats for the session tracker
+ */
+export { SessionTracker };

package/dist/ast/benchmark.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AST Parser Benchmarks
+ *
+ * Performance tests comparing Tree-sitter parsers to regex-based parsing.
+ */
+export {};
+//# sourceMappingURL=benchmark.test.d.ts.map

package/dist/ast/benchmark.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.test.d.ts","sourceRoot":"","sources":["../../src/ast/benchmark.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/ast/benchmark.test.js

@@ -0,0 +1,175 @@
+/**
+ * AST Parser Benchmarks
+ *
+ * Performance tests comparing Tree-sitter parsers to regex-based parsing.
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { initPythonParser, parsePythonAsync } from "./python/parser.js";
+import { initGoParser, parseGoAsync } from "./go/parser.js";
+// Generate large Python code sample
+function generateLargePythonCode(numFunctions, numClasses) {
+    let code = `"""Large Python module for benchmarking."""\n\n`;
+    code += `import os\nimport sys\nfrom typing import List, Dict, Optional\n\n`;
+    for (let i = 0; i < numClasses; i++) {
+        code += `class TestClass${i}:\n`;
+        code += `    """Class ${i} documentation."""\n`;
+        code += `    def __init__(self, value: int):\n`;
+        code += `        self.value = value\n\n`;
+        code += `    def method_a(self) -> int:\n`;
+        code += `        """Return the value."""\n`;
+        code += `        return self.value\n\n`;
+        code += `    async def method_b(self) -> str:\n`;
+        code += `        """Async method."""\n`;
+        code += `        return str(self.value)\n\n`;
+    }
+    for (let i = 0; i < numFunctions; i++) {
+        code += `def function_${i}(x: int, y: int) -> int:\n`;
+        code += `    """Calculate something with ${i}."""\n`;
+        code += `    return x + y + ${i}\n\n`;
+    }
+    return code;
+}
+// Generate large Go code sample
+function generateLargeGoCode(numFunctions, numStructs) {
+    let code = `package benchmark\n\n`;
+    code += `import (\n\t"fmt"\n\t"strings"\n)\n\n`;
+    for (let i = 0; i < numStructs; i++) {
+        code += `// TestStruct${i} is a test struct\n`;
+        code += `type TestStruct${i} struct {\n`;
+        code += `\tValue int\n`;
+        code += `\tName  string\n`;
+        code += `}\n\n`;
+        code += `// MethodA returns the value\n`;
+        code += `func (t *TestStruct${i}) MethodA() int {\n`;
+        code += `\treturn t.Value\n`;
+        code += `}\n\n`;
+        code += `// MethodB returns the name\n`;
+        code += `func (t TestStruct${i}) MethodB() string {\n`;
+        code += `\treturn t.Name\n`;
+        code += `}\n\n`;
+    }
+    for (let i = 0; i < numFunctions; i++) {
+        code += `// Function${i} calculates something\n`;
+        code += `func Function${i}(x, y int) int {\n`;
+        code += `\treturn x + y + ${i}\n`;
+        code += `}\n\n`;
+    }
+    return code;
+}
+describe("Parser Benchmarks", () => {
+    beforeAll(async () => {
+        // Initialize parsers
+        await Promise.all([initPythonParser(), initGoParser()]);
+    });
+    describe("Python Parser Performance", () => {
+        it("should parse small Python code quickly", async () => {
+            const code = generateLargePythonCode(10, 5);
+            const start = performance.now();
+            const structure = await parsePythonAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(0);
+            expect(structure.classes.length).toBe(5);
+            expect(elapsed).toBeLessThan(1000); // Should complete in under 1 second
+            console.log(`Python small (10 funcs, 5 classes): ${elapsed.toFixed(2)}ms`);
+        });
+        it("should parse medium Python code efficiently", async () => {
+            const code = generateLargePythonCode(50, 20);
+            const start = performance.now();
+            const structure = await parsePythonAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(50);
+            expect(structure.classes.length).toBe(20);
+            expect(elapsed).toBeLessThan(2000);
+            console.log(`Python medium (50 funcs, 20 classes): ${elapsed.toFixed(2)}ms`);
+        });
+        it("should parse large Python code acceptably", async () => {
+            const code = generateLargePythonCode(100, 50);
+            const start = performance.now();
+            const structure = await parsePythonAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(100);
+            expect(structure.classes.length).toBe(50);
+            expect(elapsed).toBeLessThan(5000);
+            console.log(`Python large (100 funcs, 50 classes): ${elapsed.toFixed(2)}ms`);
+            console.log(`  - Functions: ${structure.functions.length}`);
+            console.log(`  - Classes: ${structure.classes.length}`);
+            console.log(`  - Total lines: ${structure.totalLines}`);
+        });
+    });
+    describe("Go Parser Performance", () => {
+        it("should parse small Go code quickly", async () => {
+            const code = generateLargeGoCode(10, 5);
+            const start = performance.now();
+            const structure = await parseGoAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(0);
+            expect(structure.classes.length).toBe(5);
+            expect(elapsed).toBeLessThan(1000);
+            console.log(`Go small (10 funcs, 5 structs): ${elapsed.toFixed(2)}ms`);
+        });
+        it("should parse medium Go code efficiently", async () => {
+            const code = generateLargeGoCode(50, 20);
+            const start = performance.now();
+            const structure = await parseGoAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(50);
+            expect(structure.classes.length).toBe(20);
+            expect(elapsed).toBeLessThan(2000);
+            console.log(`Go medium (50 funcs, 20 structs): ${elapsed.toFixed(2)}ms`);
+        });
+        it("should parse large Go code acceptably", async () => {
+            const code = generateLargeGoCode(100, 50);
+            const start = performance.now();
+            const structure = await parseGoAsync(code);
+            const elapsed = performance.now() - start;
+            expect(structure.functions.length).toBeGreaterThan(100);
+            expect(structure.classes.length).toBe(50);
+            expect(elapsed).toBeLessThan(5000);
+            console.log(`Go large (100 funcs, 50 structs): ${elapsed.toFixed(2)}ms`);
+            console.log(`  - Functions: ${structure.functions.length}`);
+            console.log(`  - Structs: ${structure.classes.length}`);
+            console.log(`  - Total lines: ${structure.totalLines}`);
+        });
+    });
+    describe("Parsing accuracy comparison", () => {
+        it("should accurately count all elements in Python code", async () => {
+            const numFuncs = 25;
+            const numClasses = 10;
+            const code = generateLargePythonCode(numFuncs, numClasses);
+            const structure = await parsePythonAsync(code);
+            // Each class has 3 methods (__init__, method_a, method_b)
+            const expectedMethods = numClasses * 3;
+            const totalFunctions = structure.functions.filter((f) => f.type === "function").length;
+            const totalMethods = structure.functions.filter((f) => f.type === "method").length;
+            expect(totalFunctions).toBe(numFuncs);
+            expect(totalMethods).toBe(expectedMethods);
+            expect(structure.classes.length).toBe(numClasses);
+        });
+        it("should accurately count all elements in Go code", async () => {
+            const numFuncs = 25;
+            const numStructs = 10;
+            const code = generateLargeGoCode(numFuncs, numStructs);
+            const structure = await parseGoAsync(code);
+            // Each struct has 2 methods
+            const expectedMethods = numStructs * 2;
+            const totalFunctions = structure.functions.filter((f) => f.type === "function").length;
+            const totalMethods = structure.functions.filter((f) => f.type === "method").length;
+            expect(totalFunctions).toBe(numFuncs);
+            expect(totalMethods).toBe(expectedMethods);
+            expect(structure.classes.length).toBe(numStructs);
+        });
+    });
+    describe("Memory efficiency", () => {
+        it("should handle repeated parsing without memory leaks", async () => {
+            const pythonCode = generateLargePythonCode(20, 10);
+            const goCode = generateLargeGoCode(20, 10);
+            // Parse multiple times
+            for (let i = 0; i < 10; i++) {
+                await parsePythonAsync(pythonCode);
+                await parseGoAsync(goCode);
+            }
+            // If we get here without running out of memory, test passes
+            expect(true).toBe(true);
+        });
+    });
+});

package/dist/ast/go/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Go AST Parser Module
+ *
+ * Exports the Tree-sitter based Go parser.
+ */
+export { goTreeSitterParser, parseGo, parseGoAsync, extractGoElement, searchGoElements, initGoParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractGoDoc, getFunctionSignature, getMethodSignature, getTypeSignature, isExported, createCodeElement, } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/go/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/go/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,OAAO,EACP,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/ast/go/index.js

@@ -0,0 +1,8 @@
+/**
+ * Go AST Parser Module
+ *
+ * Exports the Tree-sitter based Go parser.
+ */
+export { goTreeSitterParser, parseGo, parseGoAsync, extractGoElement, searchGoElements, initGoParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractGoDoc, getFunctionSignature, getMethodSignature, getTypeSignature, isExported, createCodeElement, } from "./utils.js";

package/dist/ast/go/parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Go Tree-sitter Parser
+ *
+ * AST parser for Go using Tree-sitter for accurate code analysis.
+ */
+import type { CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, LanguageParser } from "../types.js";
+/**
+ * Parse Go content and extract structure
+ */
+export declare function parseGo(content: string): FileStructure;
+/**
+ * Async version of parseGo
+ */
+export declare function parseGoAsync(content: string): Promise<FileStructure>;
+/**
+ * Extract a specific element from Go code
+ */
+export declare function extractGoElement(content: string, target: ExtractionTarget, options: ExtractionOptions): Promise<ExtractedContent | null>;
+/**
+ * Search for elements matching a query
+ */
+export declare function searchGoElements(content: string, query: string): Promise<CodeElement[]>;
+/**
+ * LanguageParser implementation for Go
+ */
+export declare const goTreeSitterParser: LanguageParser;
+/**
+ * Initialize the Go parser
+ */
+export declare function initGoParser(): Promise<void>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/ast/go/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/ast/go/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAEjB,cAAc,EACf,MAAM,aAAa,CAAC;AAiErB;;GAEG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAWtD;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAW1E;AAkLD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAoElC;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAwB7F;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAmHhC,CAAC;AAEF;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAElD"}