token-pilot 0.17.0 → 0.19.0

package/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to Token Pilot will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.19.0] - 2026-04-15
+
+### Added
+- **`session_snapshot` tool** — capture current session state (goal, confirmed facts, files, blockers, next step) as a compact markdown block (<200 tokens). Call before context compaction or when switching direction in long sessions.
+- **`max_tokens` parameter** on `smart_read` and `smart_read_many` — token budget per read. Output auto-downgrades through three levels: full content → structural outline → compact (symbol names + line ranges only). Enables context-constrained sessions.
+- **Session compaction advisory** — policy engine now tracks total tool calls and tokens returned. Advises calling `session_snapshot()` when thresholds are reached (default: every 15 calls or after 8,000 tokens). Configurable via `compactionCallThreshold` and `compactionTokenThreshold`.
+- **"Why This Approach Works"** section in README explaining the 3-level optimization strategy.
+
+### Changed
+- **21 tools** (was 20) — added `session_snapshot`.
+- **MCP instructions** updated with `session_snapshot` workflow and `max_tokens` guidance.
+- Benchmark numbers updated: 55 files, 102K raw → 9K outline tokens (91% savings).
+
+## [0.18.0] - 2026-04-05
+
+### Added
+- **`read_section` tool** — read a specific section from Markdown, YAML, JSON, or CSV files. Markdown: by heading name. YAML/JSON: by top-level key. CSV: by row range (`rows:1-50`). Much cheaper than reading the whole file.
+- **`read_for_edit` section parameter** — prepare edit context for non-code file sections. Works with all 4 formats.
+- **Markdown outline with line ranges** — `smart_read` on `.md` files now shows `[L5-20]` ranges and hints for `read_section`.
+- **YAML/JSON section ranges** — `smart_read` on `.yaml`/`.json` shows top-level key ranges.
+- **CSV smart_read** — shows columns, row count, sample rows, and hints for row-range reading.
+- **4 section parsers** — `markdown-sections.ts`, `yaml-sections.ts`, `json-sections.ts`, `csv-sections.ts`.
+
+### Changed
+- **20 tools** (was 19) — added `read_section`.
+- **492 tests** (was 441).
+
+### Fixed
+- `npm audit` — resolved brace-expansion, path-to-regexp, picomatch vulnerabilities.
+
 ## [0.17.0] - 2026-04-02
 
 ### Added

package/README.md

@@ -21,16 +21,28 @@ Measured on public open-source repos using the regex fallback parser (no ast-ind
 
 | Repo | Files | Raw Tokens | Outline Tokens | Savings |
 |------|------:|----------:|--------------:|--------:|
-| [token-pilot](https://github.com/Digital-Threads/token-pilot) (TS) | 48 | 88,920 | 8,123 | **91%** |
+| [token-pilot](https://github.com/Digital-Threads/token-pilot) (TS) | 55 | 102,086 | 8,992 | **91%** |
 | [express](https://github.com/expressjs/express) (JS) | 6 | 14,421 | 193 | **99%** |
 | [fastify](https://github.com/fastify/fastify) (JS) | 23 | 50,000 | 3,161 | **94%** |
 | [flask](https://github.com/pallets/flask) (Python) | 20 | 78,236 | 7,418 | **91%** |
-| **Total** | **97** | **231,577** | **18,895** | **92%** |
+| **Total** | **104** | **244,743** | **19,764** | **92%** |
 
 > This measures `smart_read` structural outline savings only. Real sessions also benefit from session cache, dedup reminders, `read_symbol` targeted loading, and `read_for_edit` minimal context.
 >
 > Run the benchmark yourself: `npx tsx scripts/benchmark.ts`
 
+## Why This Approach Works
+
+The biggest source of token waste in AI coding sessions isn't verbose prompts — it's **redundant context**. Every time a model re-reads a file, re-sends conversation history, or loads code it doesn't need, you pay for tokens that add no value.
+
+Token Pilot attacks this at three levels:
+
+1. **Symbol-first reading** — load outlines instead of full files, drill into specific functions on demand. This alone saves 60-90% on most reads.
+2. **Context budget control** — `max_tokens` parameter on `smart_read` auto-downgrades output (full → outline → compact) to fit within a token budget per step.
+3. **Session state management** — `session_snapshot` captures session state as a compact markdown block (<200 tokens), enabling clean context compaction without losing track of what you're doing.
+
+These aren't theoretical gains. In real sessions, the combination of structural reading + targeted symbol access + session snapshots consistently reduces token usage by 80-90% compared to raw file reads.
+
 ## Installation
 
 ### Quick Start (recommended)
@@ -152,6 +164,7 @@ WHEN TO USE TOKEN PILOT (saves up to 80% tokens):
 • Reading code files → smart_read (returns structure, not raw content)
 • Need one function/class → read_symbol (loads only that symbol)
 • Exploring a directory → outline (all symbols in one call)
+• Long session? → session_snapshot (capture state before compaction)
 ...
 WHEN TO USE DEFAULT TOOLS (Token Pilot adds no value):
 • Regex/pattern search → use Grep/ripgrep, NOT find_usages
@@ -168,13 +181,13 @@ For more control, you can add rules to your project:
 - **Cursor** → `.cursorrules` in project root
 - **Codex** → `AGENTS.md` in project root
 
-## MCP Tools (19)
+## MCP Tools (21)
 
 ### Core Reading
 
 | Tool | Instead of | Description |
 |------|-----------|-------------|
-| `smart_read` | `Read` | AST structural overview: classes, functions, methods with signatures. Up to 90% savings on large files. Framework-aware: shows HTTP routes, column types, validation rules. |
+| `smart_read` | `Read` | AST structural overview: classes, functions, methods with signatures. Up to 90% savings on large files. Framework-aware: shows HTTP routes, column types, validation rules. `max_tokens` param for budget-constrained sessions. |
 | `read_symbol` | `Read` + scroll | Load source of a specific symbol. Supports `Class.method`. `show` param: full/head/tail/outline. |
 | `read_symbols` | N x `read_symbol` | Batch read multiple symbols from one file in a single call (max 10). One round-trip instead of N. |
 | `read_for_edit` | `Read` before `Edit` | Minimal RAW code around a symbol — copy directly as `old_string` for Edit tool. Batch mode: pass `symbols` array for multiple edit contexts. |
@@ -198,10 +211,11 @@ For more control, you can add rules to your project:
 | `smart_log` | raw `git log` | Structured commit history with category detection (feat/fix/refactor/docs), file stats, author breakdown. Filters by path and ref. |
 | `test_summary` | raw test output | Run tests and get structured summary: total/passed/failed + failure details. Supports vitest, jest, pytest, phpunit, go, cargo, rspec, mocha. |
 
-### Analytics
+### Session & Analytics
 
 | Tool | Description |
 |------|-------------|
+| `session_snapshot` | Capture session state as a compact markdown block (<200 tokens): goal, confirmed facts, relevant files, blockers, next step. Call before compaction or when switching direction. |
 | `session_analytics` | Token savings report: total saved, per-tool breakdown, top files, per-intent breakdown, decision insights, policy advisories. |
 
 ## CLI Commands

package/dist/config/defaults.js

@@ -59,6 +59,8 @@ export const DEFAULT_CONFIG = {
         maxFullFileReads: 10,
         warnOnLargeReads: true,
         largeReadThreshold: 2000,
+        compactionCallThreshold: 15,
+        compactionTokenThreshold: 8000,
     },
     ignore: [
         'node_modules/**',

package/dist/core/policy-engine.d.ts

@@ -16,6 +16,10 @@ export interface PolicyConfig {
     warnOnLargeReads: boolean;
     /** Token threshold for large read warning */
     largeReadThreshold: number;
+    /** Suggest compaction after N total tool calls (0 = disabled) */
+    compactionCallThreshold: number;
+    /** Suggest compaction after N total tokens returned (0 = disabled) */
+    compactionTokenThreshold: number;
 }
 export declare const DEFAULT_POLICIES: PolicyConfig;
 export interface PolicyCheckContext {
@@ -23,6 +27,8 @@ export interface PolicyCheckContext {
     tokensReturned: number;
     readForEditCalled?: Set<string>;
     editTargetPath?: string;
+    totalCallCount?: number;
+    totalTokensReturned?: number;
 }
 export interface PolicyAdvisory {
     level: 'info' | 'warn';

package/dist/core/policy-engine.js

@@ -10,6 +10,8 @@ export const DEFAULT_POLICIES = {
     maxFullFileReads: 10,
     warnOnLargeReads: true,
     largeReadThreshold: 2000,
+    compactionCallThreshold: 15,
+    compactionTokenThreshold: 8000,
 };
 /** Full-file read tools that count toward maxFullFileReads */
 const FULL_READ_TOOLS = new Set([
@@ -64,6 +66,28 @@ export function checkPolicy(policy, tool, context) {
             message: `POLICY: Consider using read_for_edit("${context.editTargetPath}") before editing to get precise edit context.`,
         };
     }
+    // 5. Session compaction advisory — by call count
+    if (policy.compactionCallThreshold > 0 &&
+        context.totalCallCount !== undefined &&
+        context.totalCallCount > 0 &&
+        context.totalCallCount % policy.compactionCallThreshold === 0) {
+        return {
+            level: 'info',
+            message: `COMPACTION: ${context.totalCallCount} tool calls this session. Consider calling session_snapshot() to capture state, then compact context.`,
+        };
+    }
+    // 6. Session compaction advisory — by total tokens
+    if (policy.compactionTokenThreshold > 0 &&
+        context.totalTokensReturned !== undefined &&
+        context.totalTokensReturned > policy.compactionTokenThreshold &&
+        context.totalCallCount !== undefined &&
+        context.totalCallCount % 5 === 0 // don't spam every call, check every 5th
+    ) {
+        return {
+            level: 'info',
+            message: `COMPACTION: ~${context.totalTokensReturned} tokens returned this session. Consider calling session_snapshot() to capture state, then compact context.`,
+        };
+    }
     return null;
 }
 /**

package/dist/core/validation.d.ts

@@ -12,6 +12,7 @@ export declare function validateSmartReadArgs(args: unknown): {
     show_docs?: boolean;
     show_references?: boolean;
     depth?: number;
+    max_tokens?: number;
 };
 /**
  * Validate read_symbol arguments.
@@ -67,6 +68,7 @@ export declare function validateFindUsagesArgs(args: unknown): FindUsagesArgs;
  */
 export declare function validateSmartReadManyArgs(args: unknown): {
     paths: string[];
+    max_tokens?: number;
 };
 /**
  * Validate read_for_edit arguments.
@@ -80,6 +82,7 @@ export declare function validateReadForEditArgs(args: unknown): {
     include_callers?: boolean;
     include_tests?: boolean;
     include_changes?: boolean;
+    section?: string;
 };
 /**
  * Validate related_files arguments.
@@ -155,6 +158,10 @@ export interface TestSummaryArgs {
     timeout?: number;
 }
 export declare function validateTestSummaryArgs(args: unknown): TestSummaryArgs;
+export declare function validateReadSectionArgs(args: unknown): {
+    path: string;
+    heading: string;
+};
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export declare function isDangerousRoot(root: string): boolean;
 //# sourceMappingURL=validation.d.ts.map

package/dist/core/validation.js

@@ -28,6 +28,7 @@ export function validateSmartReadArgs(args) {
         show_docs: optionalBool(a.show_docs, 'show_docs'),
         show_references: optionalBool(a.show_references, 'show_references'),
         depth: optionalNumber(a.depth, 'depth'),
+        max_tokens: optionalNumber(a.max_tokens, 'max_tokens'),
     };
 }
 /**
@@ -194,7 +195,7 @@ export function validateSmartReadManyArgs(args) {
             throw new Error('Each path in "paths" must be a non-empty string.');
         }
     }
-    return { paths: a.paths };
+    return { paths: a.paths, max_tokens: optionalNumber(a.max_tokens, 'max_tokens') };
 }
 function optionalString(val, name) {
     if (val === undefined || val === null)
@@ -228,8 +229,8 @@ export function validateReadForEditArgs(args) {
     if (typeof a.path !== 'string' || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0)) {
-        throw new Error('Either "symbol", "symbols", or "line" must be provided.');
+    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0) && !a.section) {
+        throw new Error('Either "symbol", "symbols", "line", or "section" must be provided.');
     }
     // Validate symbols array (batch mode)
     let symbols;
@@ -256,6 +257,7 @@ export function validateReadForEditArgs(args) {
         include_callers: optionalBool(a.include_callers, 'include_callers'),
         include_tests: optionalBool(a.include_tests, 'include_tests'),
         include_changes: optionalBool(a.include_changes, 'include_changes'),
+        section: optionalString(a.section, 'section'),
     };
 }
 /**
@@ -453,6 +455,19 @@ export function validateTestSummaryArgs(args) {
     }
     return { command: a.command, runner, timeout };
 }
+export function validateReadSectionArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('Arguments must be an object.');
+    }
+    const a = args;
+    if (typeof a.path !== 'string' || a.path.length === 0) {
+        throw new Error('Required parameter "path" must be a non-empty string.');
+    }
+    if (typeof a.heading !== 'string' || a.heading.length === 0) {
+        throw new Error('Required parameter "heading" must be a non-empty string.');
+    }
+    return { path: a.path, heading: a.heading };
+}
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export function isDangerousRoot(root) {
     const normalized = root.replace(/\/+$/, '') || '/';

package/dist/handlers/csv-sections.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CSV parser — column-aware reading with row/column subsetting.
+ */
+export interface CsvOutline {
+    columns: string[];
+    rowCount: number;
+    sampleRows: string[][];
+}
+export interface CsvSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse CSV into an outline: columns, row count, sample.
+ * Simple parser — handles quoted fields with commas.
+ */
+export declare function parseCsvOutline(content: string): CsvOutline;
+/**
+ * Parse a row range specification into a CsvSection.
+ * Supported formats:
+ *   "rows:1-50" — row range (1-indexed, refers to data rows, not header)
+ *   "rows:1-50" with column filter isn't supported at section level
+ */
+export declare function parseCsvSectionSpec(heading: string, totalDataRows: number): CsvSection | null;
+/**
+ * Extract CSV rows for a section. Returns header + requested rows.
+ */
+export declare function extractCsvSectionContent(lines: string[], section: CsvSection): string;
+/**
+ * Format CSV outline for smart_read output.
+ */
+export declare function formatCsvOutline(filePath: string, outline: CsvOutline, lineCount: number): string;
+//# sourceMappingURL=csv-sections.d.ts.map

package/dist/handlers/csv-sections.js

@@ -0,0 +1,129 @@
+/**
+ * CSV parser — column-aware reading with row/column subsetting.
+ */
+/**
+ * Parse CSV into an outline: columns, row count, sample.
+ * Simple parser — handles quoted fields with commas.
+ */
+export function parseCsvOutline(content) {
+    const lines = content.split('\n').filter(l => l.trim());
+    if (lines.length === 0)
+        return { columns: [], rowCount: 0, sampleRows: [] };
+    const columns = parseCsvRow(lines[0]);
+    const dataLines = lines.slice(1);
+    const sampleRows = dataLines.slice(0, 5).map(parseCsvRow);
+    return {
+        columns,
+        rowCount: dataLines.length,
+        sampleRows,
+    };
+}
+/**
+ * Parse a row range specification into a CsvSection.
+ * Supported formats:
+ *   "rows:1-50" — row range (1-indexed, refers to data rows, not header)
+ *   "rows:1-50" with column filter isn't supported at section level
+ */
+export function parseCsvSectionSpec(heading, totalDataRows) {
+    // rows:N-M format
+    const rowMatch = heading.match(/^rows?:\s*(\d+)\s*-\s*(\d+)$/i);
+    if (rowMatch) {
+        const start = Math.max(1, parseInt(rowMatch[1], 10));
+        const end = Math.min(totalDataRows, parseInt(rowMatch[2], 10));
+        if (start > end || start > totalDataRows)
+            return null;
+        // +1 for header line offset
+        return {
+            heading: `rows ${start}-${end}`,
+            startLine: start + 1, // +1 because line 1 is header
+            endLine: end + 1,
+            lineCount: end - start + 1,
+        };
+    }
+    // Single row number
+    const singleMatch = heading.match(/^rows?:\s*(\d+)$/i);
+    if (singleMatch) {
+        const row = parseInt(singleMatch[1], 10);
+        if (row < 1 || row > totalDataRows)
+            return null;
+        return {
+            heading: `row ${row}`,
+            startLine: row + 1,
+            endLine: row + 1,
+            lineCount: 1,
+        };
+    }
+    return null;
+}
+/**
+ * Extract CSV rows for a section. Returns header + requested rows.
+ */
+export function extractCsvSectionContent(lines, section) {
+    const header = lines[0]; // always include header
+    const dataRows = lines.slice(section.startLine - 1, section.endLine);
+    return [header, ...dataRows].join('\n');
+}
+/**
+ * Parse a single CSV row handling quoted fields.
+ */
+function parseCsvRow(line) {
+    const fields = [];
+    let current = '';
+    let inQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (inQuote) {
+            if (ch === '"') {
+                if (i + 1 < line.length && line[i + 1] === '"') {
+                    current += '"';
+                    i++; // skip escaped quote
+                }
+                else {
+                    inQuote = false;
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        else {
+            if (ch === '"') {
+                inQuote = true;
+            }
+            else if (ch === ',') {
+                fields.push(current.trim());
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+    }
+    fields.push(current.trim());
+    return fields;
+}
+/**
+ * Format CSV outline for smart_read output.
+ */
+export function formatCsvOutline(filePath, outline, lineCount) {
+    const lines = [
+        `FILE: ${filePath} (${lineCount} lines, CSV)`,
+        '',
+        `COLUMNS (${outline.columns.length}): ${outline.columns.join(', ')}`,
+        `ROWS: ${outline.rowCount}`,
+        '',
+    ];
+    if (outline.sampleRows.length > 0) {
+        lines.push(`SAMPLE (first ${outline.sampleRows.length} rows):`);
+        for (const row of outline.sampleRows) {
+            // Format as: col1=val1, col2=val2, ...
+            const pairs = outline.columns.map((col, i) => `${col}=${row[i] ?? ''}`);
+            lines.push(`  ${pairs.join(', ')}`);
+        }
+    }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="rows:1-50") to load specific rows.`);
+    lines.push(`      Use read_section("${filePath}", heading="rows:${outline.rowCount}") for last row.`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=csv-sections.js.map

package/dist/handlers/json-sections.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSON section parser — parses top-level keys with line ranges.
+ */
+export interface JsonSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse JSON into sections based on top-level keys.
+ * Works with formatted JSON (pretty-printed). For minified JSON, returns empty.
+ */
+export declare function parseJsonSections(content: string): JsonSection[];
+export declare function findJsonSection(sections: JsonSection[], heading: string): JsonSection | undefined;
+export declare function extractJsonSectionContent(lines: string[], section: JsonSection): string;
+//# sourceMappingURL=json-sections.d.ts.map

package/dist/handlers/json-sections.js

@@ -0,0 +1,66 @@
+/**
+ * JSON section parser — parses top-level keys with line ranges.
+ */
+/**
+ * Parse JSON into sections based on top-level keys.
+ * Works with formatted JSON (pretty-printed). For minified JSON, returns empty.
+ */
+export function parseJsonSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    if (lines.length < 3)
+        return []; // minified or trivial
+    // Find top-level keys: lines matching /^\s{0,2}"key":/ (0-2 spaces indent = top level)
+    const topKeys = [];
+    // Track brace depth to identify top-level
+    let depth = 0;
+    let inString = false;
+    let lineIdx = 0;
+    for (lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        // Simple top-level key detection: at depth 1 (inside root object)
+        // Match: "key": or "key" : at the beginning of a line (with indent)
+        if (depth === 1) {
+            const keyMatch = line.match(/^\s*"([^"]+)"\s*:/);
+            if (keyMatch) {
+                topKeys.push({ key: keyMatch[1], line: lineIdx + 1 });
+            }
+        }
+        // Track depth (simplified — doesn't handle strings perfectly but good enough for formatted JSON)
+        for (let ci = 0; ci < line.length; ci++) {
+            const ch = line[ci];
+            if (ch === '"' && (ci === 0 || line[ci - 1] !== '\\')) {
+                inString = !inString;
+            }
+            if (!inString) {
+                if (ch === '{' || ch === '[')
+                    depth++;
+                if (ch === '}' || ch === ']')
+                    depth--;
+            }
+        }
+    }
+    if (topKeys.length === 0)
+        return [];
+    const sections = [];
+    for (let i = 0; i < topKeys.length; i++) {
+        const start = topKeys[i].line;
+        const end = i + 1 < topKeys.length ? topKeys[i + 1].line - 1 : lines.length - 1; // -1 to exclude closing }
+        sections.push({
+            heading: topKeys[i].key,
+            startLine: start,
+            endLine: end,
+            lineCount: end - start + 1,
+        });
+    }
+    return sections;
+}
+export function findJsonSection(sections, heading) {
+    const normalized = heading.trim().toLowerCase();
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractJsonSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=json-sections.js.map

package/dist/handlers/markdown-sections.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Markdown section parser — shared helper for section-aware tools.
+ * Parses heading structure with line ranges for targeted reading.
+ */
+export interface MarkdownSection {
+    heading: string;
+    level: number;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+export declare function parseMarkdownSections(content: string): MarkdownSection[];
+export declare function findSection(sections: MarkdownSection[], heading: string): MarkdownSection | undefined;
+export declare function extractSectionContent(lines: string[], section: MarkdownSection): string;
+//# sourceMappingURL=markdown-sections.d.ts.map

package/dist/handlers/markdown-sections.js

@@ -0,0 +1,49 @@
+/**
+ * Markdown section parser — shared helper for section-aware tools.
+ * Parses heading structure with line ranges for targeted reading.
+ */
+export function parseMarkdownSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    const headings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+        if (match) {
+            headings.push({
+                heading: match[2].trim(),
+                level: match[1].length,
+                line: i + 1,
+            });
+        }
+    }
+    if (headings.length === 0)
+        return [];
+    const sections = [];
+    for (let i = 0; i < headings.length; i++) {
+        const current = headings[i];
+        let endLine = lines.length;
+        for (let j = i + 1; j < headings.length; j++) {
+            if (headings[j].level <= current.level) {
+                endLine = headings[j].line - 1;
+                break;
+            }
+        }
+        sections.push({
+            heading: current.heading,
+            level: current.level,
+            startLine: current.line,
+            endLine,
+            lineCount: endLine - current.line + 1,
+        });
+    }
+    return sections;
+}
+export function findSection(sections, heading) {
+    const normalized = heading.replace(/^#+\s*/, '').trim().toLowerCase();
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=markdown-sections.js.map