wavescope-mcp 1.0.2

package/README.md

@@ -0,0 +1,131 @@
+# WaveScope MCP
+
+Wavelet-based multi-resolution context management for LLMs via MCP.
+
+Provides a **zoomable view** of code files — the model can look at high-level
+structure, then drill down to specific regions as needed, without loading
+entire files into context.
+
+## How it works
+
+1. **Structural signal** — each line gets an importance score based on
+   indentation, keywords (`class`, `def`, `export`, etc.), and comment status.
+
+2. **Ricker wavelet transform** — the signal is convolved with Ricker (Mexican
+   hat) wavelets at 8 scales (1–128), detecting structural boundaries at
+   multiple resolutions.
+
+3. **Multi-scale peaks** — coefficient maxima are extracted and sorted by
+   magnitude, identifying the most important structural transitions.
+
+4. **Band assembly** — three zoom levels, sized as a fraction of the query
+   `radius` (default 300):
+   - **Fine** (scales 1–2): raw lines in ±`radius/5` (≥10 lines)
+   - **Medium** (scales 4–16): function/class signatures in ±`radius/2`
+   - **Coarse** (scales 32–128): section-level structural summary across ±`radius`
+
+## Installation
+
+```bash
+pnpm install
+pnpm build
+```
+
+## Usage
+
+### Running as MCP server
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "wavescope": {
+      "command": "node",
+      "args": ["/path/to/wavescope-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+### Tools
+
+#### `query_wavelet_context`
+
+Multi-resolution view around a position.
+
+- `file` — absolute path to the file
+- `center` — line number (0-indexed)
+- `radius` — total range to consider, 10–2000 (default 300)
+
+Returns `center`, `clamped` (and `clampedFrom` when out of range was
+clamped), three `fine`/`medium`/`coarse` bands, and detected wavelet peaks.
+
+#### `get_important_positions`
+
+Find structural boundaries (class/function defs, imports, etc.).
+
+- exactly one of `file` (single file path) or `directory` (project-wide search)
+- `min_coefficient` — raw wavelet coefficient threshold, 0–10 (default 0.3).
+  Same semantics in both single-file and project mode.
+- `limit` — max results, 1–100 (default 20)
+
+#### `get_wavelet_coefficients`
+
+Raw wavelet coefficients for custom analysis.
+
+- `file`, `start`, `end`, `scale` (required, 1–128)
+
+Returned object includes `scale` (the actual scale used) and
+`requestedScale` (the original scale you asked for) — they differ when
+the requested scale isn't in the index and the nearest available one is
+substituted.
+
+#### `get_summary_at_scale`
+
+Compressed view of a region using specified scale peaks.
+
+- `file`, `start`, `end`, `scale` (optional — auto-selected based on
+  region size if omitted: ≤50 lines → 2, ≤200 → 8, ≤800 → 32, >800 → 128)
+
+## Development
+
+```bash
+pnpm install         # Install dependencies
+pnpm build           # TypeScript compile
+pnpm dev             # Run with tsx
+pnpm test            # Watch mode
+pnpm test:run        # Run tests once
+pnpm test:coverage   # Run with coverage
+pnpm typecheck       # Type check only
+```
+
+## Architecture
+
+```
+src/
+├── index.ts       # MCP server entry, tool handlers
+├── signal.ts      # Per-line structural importance signal
+├── wavelet.ts     # Ricker CWT + peak detection
+├── context.ts     # FileContext: query_wavelet_context, get_important_positions, etc.
+├── project.ts     # ProjectIndex: multi-file discovery and indexing
+├── language.ts    # Language-specific keyword weights
+└── *.test.ts      # Tests
+```
+
+## Supported languages
+
+Python (`.py`, `.pyi`, `.pyx`), TypeScript (`.ts`, `.tsx`, `.mts`, `.cts`),
+JavaScript (`.js`, `.jsx`, `.mjs`, `.cjs`), Go, Rust, Java, Ruby (incl.
+`Rakefile`, `Gemfile`), PHP, Swift, Kotlin, Scala, Clojure (`.clj`, `.cljs`,
+`.cljc`, `.edn`). Non-recognized extensions use a minimal generic
+configuration.
+
+## Project-wide indexing limits
+
+When `get_important_positions` is called with `directory`, the indexer:
+
+- honors a root-level `.gitignore` (plain patterns; no negations);
+- skips files larger than 2 MB and binary files (NUL byte sniff in first 4 KB);
+- caps discovery at 5000 files (a `truncated` flag is set if exceeded);
+- follows symlinks once via `realpath`, refusing any that escape the project root.

package/dist/context.d.ts

@@ -0,0 +1,97 @@
+import { LanguageConfig } from "./language.js";
+import { WaveletCoefficients } from "./wavelet.js";
+export interface ImportantPosition {
+    position: number;
+    coefficient: number;
+    scale: number;
+    label: string;
+    filename?: string;
+}
+export interface BandResult {
+    range: [number, number];
+    content: string;
+}
+export interface WaveletContextResult {
+    center: number;
+    clamped: boolean;
+    /** Original `center` requested by caller, present only when clamped. */
+    clampedFrom?: number;
+    bands: {
+        fine: BandResult;
+        medium: BandResult;
+        coarse: BandResult;
+    };
+    waveletPeaks: ImportantPosition[];
+}
+export interface WaveletCoefficientsResult {
+    /** The actual scale used (may differ from `requestedScale`). */
+    scale: number;
+    /** The scale originally requested by the caller. */
+    requestedScale: number;
+    /** Raw coefficient slice. */
+    coefficients: number[];
+}
+/**
+ * FileContext holds the wavelet index for a single file and provides
+ * multi-resolution query methods.
+ */
+export declare class FileContext {
+    readonly filename: string;
+    readonly lines: string[];
+    readonly language: LanguageConfig;
+    readonly signal: number[];
+    readonly coefficients: WaveletCoefficients;
+    get lineCount(): number;
+    private _allPeaks;
+    constructor(filename: string, content: string);
+    /**
+     * Returns all peaks (lazy, cached). Multi-scale peaks at the same
+     * position are preserved so that band assembly can filter by scale range.
+     */
+    private getAllPeaks;
+    /**
+     * Find important structural positions (class/function boundaries, etc.)
+     * sorted by wavelet coefficient magnitude.
+     */
+    getImportantPositions(minCoefficient?: number, limit?: number): ImportantPosition[];
+    /**
+     * Multi-resolution context centered at a position.
+     *
+     * Returns three bands:
+     * - fine: raw lines in a narrow window (~radius/5)
+     * - medium: peak-based summary in a medium window (~radius/2)
+     * - coarse: section-level overview across the full radius
+     */
+    queryWaveletContext(center: number, radius: number): WaveletContextResult;
+    /**
+     * Pick a representative scale for a region of the given size, matched
+     * to the wavelength most useful for summarizing structure at that
+     * resolution. Snaps to the closest available scale.
+     *
+     * Heuristic (region size in lines → target scale):
+     *   ≤ 50    → 2
+     *   ≤ 200   → 8
+     *   ≤ 800   → 32
+     *   > 800   → 128
+     */
+    autoScale(start: number, end: number): number;
+    /**
+     * Compressed/summarized view of a region using wavelet peaks at a given scale.
+     */
+    getSummaryAtScale(start: number, end: number, scale?: number): string;
+    getWaveletCoefficients(start: number, end: number, scale: number): WaveletCoefficientsResult;
+    private dedupPeaks;
+    /**
+     * Snap `scale` to the nearest scale present in the wavelet index.
+     * Ties (e.g. 3 → equidistant from 2 and 4) resolve to the lower scale
+     * (insertion-order stable on Array.reduce).
+     */
+    private findClosestScale;
+    private inferLabel;
+    private buildMediumBand;
+    private buildCoarseBand;
+    private buildRangeSummary;
+    private buildPeakSummary;
+    private buildSectionSummary;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAGL,mBAAmB,EAEpB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE;QACL,IAAI,EAAE,UAAU,CAAC;QACjB,MAAM,EAAE,UAAU,CAAC;QACnB,MAAM,EAAE,UAAU,CAAC;KACpB,CAAC;IACF,YAAY,EAAE,iBAAiB,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AASD;;;GAGG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAE3C,IAAI,SAAS,IAAI,MAAM,CAA8B;IAGrD,OAAO,CAAC,SAAS,CAAuB;gBAE5B,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAqB7C;;;OAGG;IACH,OAAO,CAAC,WAAW;IAQnB;;;OAGG;IACH,qBAAqB,CACnB,cAAc,GAAE,MAAY,EAC5B,KAAK,GAAE,MAAW,GACjB,iBAAiB,EAAE;IAsBtB;;;;;;;OAOG;IACH,mBAAmB,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,oBAAoB;IAmEvB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAU7C;;OAEG;IACH,iBAAiB,CACf,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,MAAM,GACb,MAAM;IA2BT,sBAAsB,CACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,yBAAyB;IAyB5B,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,UAAU;IA0GlB,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,eAAe;IA6BvB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,mBAAmB;CAiC5B"}

package/dist/context.js

@@ -0,0 +1,429 @@
+import { detectLanguage } from "./language.js";
+import { computeSignal } from "./signal.js";
+import { computeCWT, detectPeaks, } from "./wavelet.js";
+/** Band scale ranges used by buildMediumBand / buildCoarseBand. */
+const BAND_SCALES = {
+    fine: [1, 2],
+    medium: [4, 16],
+    coarse: [32, 128],
+};
+/**
+ * FileContext holds the wavelet index for a single file and provides
+ * multi-resolution query methods.
+ */
+export class FileContext {
+    filename;
+    lines;
+    language;
+    signal;
+    coefficients;
+    get lineCount() { return this.lines.length; }
+    // Cached peak set — lazily computed once
+    _allPeaks = null;
+    constructor(filename, content) {
+        this.filename = filename;
+        this.lines = content.split("\n");
+        // Preserve trailing newline: if content ends with \n, ignore the empty last line
+        if (content.endsWith("\n") && this.lines[this.lines.length - 1] === "") {
+            this.lines.pop();
+        }
+        // Handle truly empty content
+        if (this.lines.length === 1 && this.lines[0] === "") {
+            this.lines = [];
+        }
+        this.language = detectLanguage(filename);
+        this.signal = computeSignal(this.lines, this.language);
+        this.coefficients = computeCWT(this.signal);
+    }
+    // ─── Cached peak access ──────────────────────────────────
+    /**
+     * Returns all peaks (lazy, cached). Multi-scale peaks at the same
+     * position are preserved so that band assembly can filter by scale range.
+     */
+    getAllPeaks() {
+        if (this._allPeaks)
+            return this._allPeaks;
+        this._allPeaks = detectPeaks(this.coefficients, 0.0, 1000);
+        return this._allPeaks;
+    }
+    // ─── Public API ──────────────────────────────────────────
+    /**
+     * Find important structural positions (class/function boundaries, etc.)
+     * sorted by wavelet coefficient magnitude.
+     */
+    getImportantPositions(minCoefficient = 0.3, limit = 20) {
+        const allPeaks = this.getAllPeaks();
+        // Deduplicate by position: keep the peak with the largest |coefficient|
+        const bestMap = new Map();
+        for (const p of allPeaks) {
+            if (Math.abs(p.coefficient) < minCoefficient)
+                continue;
+            const existing = bestMap.get(p.position);
+            if (!existing || Math.abs(p.coefficient) > Math.abs(existing.coefficient)) {
+                bestMap.set(p.position, p);
+            }
+        }
+        return [...bestMap.values()]
+            .sort((a, b) => Math.abs(b.coefficient) - Math.abs(a.coefficient))
+            .slice(0, limit)
+            .map((p) => ({
+            position: p.position,
+            coefficient: p.coefficient,
+            scale: p.scale,
+            label: this.inferLabel(p.position),
+        }));
+    }
+    /**
+     * Multi-resolution context centered at a position.
+     *
+     * Returns three bands:
+     * - fine: raw lines in a narrow window (~radius/5)
+     * - medium: peak-based summary in a medium window (~radius/2)
+     * - coarse: section-level overview across the full radius
+     */
+    queryWaveletContext(center, radius) {
+        if (this.lineCount === 0) {
+            const empty = {
+                center: 0,
+                clamped: center !== 0,
+                bands: {
+                    fine: { range: [0, 0], content: "" },
+                    medium: { range: [0, 0], content: "" },
+                    coarse: { range: [0, 0], content: "" },
+                },
+                waveletPeaks: [],
+            };
+            if (empty.clamped)
+                empty.clampedFrom = center;
+            return empty;
+        }
+        const cl = Math.max(0, Math.min(center, this.lineCount - 1));
+        const clamped = center !== cl;
+        const total = this.lineCount;
+        // Fine band: ±radius/5, minimum 10 lines
+        const fineRadius = Math.max(10, Math.floor(radius / 5));
+        const fineStart = Math.max(0, cl - fineRadius);
+        const fineEnd = Math.min(total - 1, cl + fineRadius);
+        // Medium band: ±radius/2
+        const medRadius = Math.floor(radius / 2);
+        const medStart = Math.max(0, cl - medRadius);
+        const medEnd = Math.min(total - 1, cl + medRadius);
+        // Coarse band: full radius
+        const coarseStart = Math.max(0, cl - radius);
+        const coarseEnd = Math.min(total - 1, cl + radius);
+        // Get peaks in the full radius
+        const allPeaks = this.getAllPeaks();
+        const nearbyPeaks = allPeaks.filter((p) => p.position >= coarseStart && p.position <= coarseEnd);
+        const result = {
+            center: cl,
+            clamped,
+            bands: {
+                fine: {
+                    range: [fineStart, fineEnd],
+                    content: this.lines.slice(fineStart, fineEnd + 1).join("\n"),
+                },
+                medium: {
+                    range: [medStart, medEnd],
+                    content: this.buildMediumBand(medStart, medEnd, nearbyPeaks),
+                },
+                coarse: {
+                    range: [coarseStart, coarseEnd],
+                    content: this.buildCoarseBand(coarseStart, coarseEnd, nearbyPeaks),
+                },
+            },
+            waveletPeaks: this.dedupPeaks(nearbyPeaks).slice(0, 10).map((p) => ({
+                position: p.position,
+                coefficient: p.coefficient,
+                scale: p.scale,
+                label: this.inferLabel(p.position),
+            })),
+        };
+        if (clamped)
+            result.clampedFrom = center;
+        return result;
+    }
+    /**
+     * Pick a representative scale for a region of the given size, matched
+     * to the wavelength most useful for summarizing structure at that
+     * resolution. Snaps to the closest available scale.
+     *
+     * Heuristic (region size in lines → target scale):
+     *   ≤ 50    → 2
+     *   ≤ 200   → 8
+     *   ≤ 800   → 32
+     *   > 800   → 128
+     */
+    autoScale(start, end) {
+        const size = Math.max(1, end - start + 1);
+        let target;
+        if (size <= 50)
+            target = 2;
+        else if (size <= 200)
+            target = 8;
+        else if (size <= 800)
+            target = 32;
+        else
+            target = 128;
+        return this.findClosestScale(target);
+    }
+    /**
+     * Compressed/summarized view of a region using wavelet peaks at a given scale.
+     */
+    getSummaryAtScale(start, end, scale) {
+        if (this.lines.length === 0)
+            return "";
+        let s = Math.max(0, start);
+        let e = Math.min(this.lines.length - 1, end);
+        if (s > e)
+            [s, e] = [e, s];
+        const allPeaks = this.getAllPeaks();
+        // Auto-select a representative scale when caller doesn't pin one.
+        const resolvedScale = scale !== undefined
+            ? this.findClosestScale(scale)
+            : this.autoScale(s, e);
+        const peaksInRange = allPeaks.filter((p) => p.position >= s &&
+            p.position <= e &&
+            p.scale === resolvedScale);
+        if (peaksInRange.length === 0) {
+            return this.buildRangeSummary(s, e);
+        }
+        return this.buildPeakSummary(peaksInRange, s, e);
+    }
+    getWaveletCoefficients(start, end, scale) {
+        if (this.coefficients.coefficients.length === 0) {
+            return { scale, requestedScale: scale, coefficients: [] };
+        }
+        const resolvedScale = this.findClosestScale(scale);
+        const scaleIdx = this.coefficients.scales.indexOf(resolvedScale);
+        const coeffs = this.coefficients.coefficients[scaleIdx];
+        if (!coeffs) {
+            return { scale: resolvedScale, requestedScale: scale, coefficients: [] };
+        }
+        let s = Math.max(0, start);
+        let e = Math.min(coeffs.length - 1, end);
+        if (s > e)
+            [s, e] = [e, s];
+        return {
+            scale: resolvedScale,
+            requestedScale: scale,
+            coefficients: coeffs.slice(s, e + 1),
+        };
+    }
+    // ─── private helpers ──────────────────────────────────────
+    dedupPeaks(peaks) {
+        const bestMap = new Map();
+        for (const p of peaks) {
+            const existing = bestMap.get(p.position);
+            if (!existing || Math.abs(p.coefficient) > Math.abs(existing.coefficient)) {
+                bestMap.set(p.position, p);
+            }
+        }
+        return [...bestMap.values()];
+    }
+    /**
+     * Snap `scale` to the nearest scale present in the wavelet index.
+     * Ties (e.g. 3 → equidistant from 2 and 4) resolve to the lower scale
+     * (insertion-order stable on Array.reduce).
+     */
+    findClosestScale(scale) {
+        const scales = this.coefficients.scales;
+        if (scales.length === 0)
+            return scale;
+        return scales.reduce((prev, curr) => Math.abs(curr - scale) < Math.abs(prev - scale) ? curr : prev);
+    }
+    inferLabel(pos) {
+        if (pos < 0 || pos >= this.lines.length)
+            return "unknown";
+        const line = this.lines[pos].trim();
+        if (!line)
+            return `line ${pos}`;
+        // Tokenize on code delimiters (same regex as signal.ts) so that
+        // forms like "(defn foo" correctly produce token "defn"
+        const tokens = line.split(/[\s()[\]{},;:'".=!<>+\-*/&|^~%@#`]+/).filter(Boolean);
+        // Also keep whitespace-split tokens as fallback for label reading
+        const wsTokens = line.split(/\s+/);
+        if (this.language.name === "python") {
+            if (wsTokens[0] === "class")
+                return `class ${wsTokens[1]?.replace(":", "")}`;
+            if (wsTokens[0] === "def")
+                return `def ${wsTokens[1]?.split("(")[0]}`;
+            if (wsTokens[0] === "import")
+                return `import ${wsTokens.slice(1).join(" ")}`;
+            if (wsTokens[0] === "from")
+                return `from ${wsTokens.slice(1).join(" ")}`;
+            if (line.startsWith("@"))
+                return `decorator ${line.split(/[\s()]+/)[0].slice(1)}`;
+            if (line.startsWith("if __name__"))
+                return "main guard";
+        }
+        else {
+            // Decorator detection (before keyword checks so "export @foo class" works)
+            if (line.startsWith("@")) {
+                const decorator = line.split(/[\s()]+/)[0];
+                return `decorator ${decorator.slice(1)}`;
+            }
+            // Import/export at top (before keyword checks to capture "export class Foo")
+            if (wsTokens[0] === "import")
+                return `import ${wsTokens.slice(1).join(" ")}`;
+            if (wsTokens[0] === "export") {
+                const rest = wsTokens.slice(1).join(" ");
+                return `export ${rest.substring(0, 40)}`;
+            }
+            // Use code-delimiter tokens for keyword matching
+            if (tokens.includes("class")) {
+                const idx = tokens.indexOf("class");
+                return `class ${tokens[idx + 1]?.replace(/\{.*/, "").replace(/extends|implements/g, "").trim()}`;
+            }
+            if (tokens.includes("interface")) {
+                const idx = tokens.indexOf("interface");
+                return `interface ${tokens[idx + 1]?.replace(/\{.*/, "").trim()}`;
+            }
+            if (tokens.includes("enum")) {
+                const idx = tokens.indexOf("enum");
+                return `enum ${tokens[idx + 1]?.replace(/\{.*/, "").trim()}`;
+            }
+            if (tokens.includes("trait")) {
+                const idx = tokens.indexOf("trait");
+                return `trait ${tokens[idx + 1]?.replace(/\{.*/, "").trim()}`;
+            }
+            if (tokens.includes("struct")) {
+                const idx = tokens.indexOf("struct");
+                return `struct ${tokens[idx + 1]?.replace(/\{.*/, "").trim()}`;
+            }
+            if (tokens.includes("object")) {
+                const idx = tokens.indexOf("object");
+                return `object ${tokens[idx + 1]?.replace(/\{.*/, "").trim()}`;
+            }
+            if (tokens.includes("function")) {
+                const idx = tokens.indexOf("function");
+                return `function ${tokens[idx + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("fn") && !tokens.includes("defn")) {
+                // Rust — check defn first to avoid false match on Clojure
+                return `fn ${tokens[tokens.indexOf("fn") + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("fun")) {
+                // Kotlin
+                return `fun ${tokens[tokens.indexOf("fun") + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("func")) {
+                // Go
+                return `func ${tokens[tokens.indexOf("func") + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("def")) {
+                // Scala
+                return `def ${tokens[tokens.indexOf("def") + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("defn")) {
+                // Clojure
+                return `defn ${tokens[tokens.indexOf("defn") + 1]}`;
+            }
+            if (tokens.includes("defmacro")) {
+                return `defmacro ${tokens[tokens.indexOf("defmacro") + 1]}`;
+            }
+            if (tokens.includes("defprotocol")) {
+                return `defprotocol ${tokens[tokens.indexOf("defprotocol") + 1]}`;
+            }
+            if (tokens.includes("defrecord")) {
+                return `defrecord ${tokens[tokens.indexOf("defrecord") + 1]}`;
+            }
+            if (tokens.includes("deftype")) {
+                return `deftype ${tokens[tokens.indexOf("deftype") + 1]}`;
+            }
+            if (tokens.includes("impl")) {
+                return `impl ${tokens[tokens.indexOf("impl") + 1]?.split("(")[0]}`;
+            }
+            if (tokens.includes("protocol")) {
+                return `protocol ${tokens[tokens.indexOf("protocol") + 1]}`;
+            }
+            if (tokens.includes("extension")) {
+                return `extension ${tokens[tokens.indexOf("extension") + 1]}`;
+            }
+        }
+        return line.substring(0, 50);
+    }
+    buildMediumBand(start, end, peaks) {
+        const medPeaks = peaks
+            .filter((p) => p.position >= start &&
+            p.position <= end &&
+            p.scale >= BAND_SCALES.medium[0] &&
+            p.scale <= BAND_SCALES.medium[1])
+            .sort((a, b) => a.position - b.position);
+        if (medPeaks.length === 0) {
+            return this.buildRangeSummary(start, end);
+        }
+        return this.buildPeakSummary(medPeaks, start, end);
+    }
+    buildCoarseBand(start, end, peaks) {
+        const coarsePeaks = peaks
+            .filter((p) => p.position >= start &&
+            p.position <= end &&
+            p.scale >= BAND_SCALES.coarse[0] &&
+            p.scale <= BAND_SCALES.coarse[1])
+            .sort((a, b) => a.position - b.position);
+        if (coarsePeaks.length === 0) {
+            const allInRange = peaks
+                .filter((p) => p.position >= start && p.position <= end)
+                .sort((a, b) => a.position - b.position);
+            if (allInRange.length === 0) {
+                return this.buildRangeSummary(start, end);
+            }
+            return this.buildSectionSummary(allInRange, start, end);
+        }
+        return this.buildSectionSummary(coarsePeaks, start, end);
+    }
+    buildRangeSummary(start, end) {
+        if (start > end)
+            return "";
+        const previewLines = Math.min(5, end - start + 1);
+        const parts = [];
+        const step = Math.ceil((end - start + 1) / previewLines);
+        for (let i = start; i <= end; i += step) {
+            const line = this.lines[i].trim();
+            if (line) {
+                parts.push(`[${i}] ${line.substring(0, 80)}`);
+            }
+        }
+        return parts.join("\n");
+    }
+    buildPeakSummary(peaks, rangeStart, rangeEnd) {
+        const parts = [];
+        let prevEnd = rangeStart - 1;
+        for (const peak of peaks) {
+            if (peak.position > prevEnd + 1) {
+                parts.push(`[${prevEnd + 1}-${peak.position - 1}] ...`);
+            }
+            parts.push(`[${peak.position}] ${this.lines[peak.position].trim().substring(0, 80)}`);
+            prevEnd = peak.position;
+        }
+        if (prevEnd < rangeEnd) {
+            parts.push(`[${prevEnd + 1}-${rangeEnd}] ...`);
+        }
+        return parts.join("\n");
+    }
+    buildSectionSummary(peaks, rangeStart, rangeEnd) {
+        const parts = [];
+        let prevPos = rangeStart;
+        let currentSection = "";
+        // Set the first section label BEFORE the loop so the initial
+        // region [rangeStart, firstPeak-1] gets a label
+        if (peaks.length > 0) {
+            currentSection = this.inferLabel(peaks[0].position);
+        }
+        for (const peak of peaks) {
+            if (currentSection && prevPos < peak.position) {
+                parts.push(`[${prevPos}-${peak.position - 1}] ${currentSection}`);
+            }
+            currentSection = this.inferLabel(peak.position);
+            prevPos = peak.position;
+        }
+        if (currentSection && prevPos <= rangeEnd) {
+            parts.push(`[${prevPos}-${rangeEnd}] ${currentSection}`);
+        }
+        if (parts.length === 0) {
+            parts.push(`[${rangeStart}-${rangeEnd}] (code region)`);
+        }
+        return parts.join("\n");
+    }
+}
+//# sourceMappingURL=context.js.map