token-pilot 0.17.0 → 0.19.0

package/dist/handlers/non-code.js

@@ -2,12 +2,16 @@ import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
+import { parseMarkdownSections } from './markdown-sections.js';
+import { parseYamlSections } from './yaml-sections.js';
+import { parseJsonSections } from './json-sections.js';
+import { parseCsvOutline, formatCsvOutline } from './csv-sections.js';
 /**
  * Detect if a file is a non-code structured file (JSON, YAML, Markdown, etc.)
  */
 export function isNonCodeStructured(filePath) {
     const ext = extname(filePath).toLowerCase();
-    return ['.json', '.yaml', '.yml', '.md', '.markdown', '.toml'].includes(ext);
+    return ['.json', '.yaml', '.yml', '.md', '.markdown', '.toml', '.csv'].includes(ext);
 }
 /**
  * Generate a structural summary for non-code files.
@@ -37,6 +41,9 @@ export async function handleNonCodeRead(filePath, projectRoot, contextRegistry,
         case '.toml':
             summary = summarizeToml(filePath, content, lines.length);
             break;
+        case '.csv':
+            summary = summarizeCsv(filePath, content, lines.length);
+            break;
         default:
             return null;
     }
@@ -87,14 +94,34 @@ function summarizeJson(filePath, content, lineCount) {
     catch {
         lines.push('(Invalid JSON — parse error)');
     }
+    // Add section line ranges for navigation
+    const jsonSections = parseJsonSections(content);
+    if (jsonSections.length > 0) {
+        lines.push('');
+        lines.push('SECTION RANGES:');
+        for (const sec of jsonSections) {
+            lines.push(`  "${sec.heading}" [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
+        }
+    }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<key>") to load a specific section.`);
     return lines.join('\n');
 }
 function summarizeYaml(filePath, content, lineCount) {
     const lines = [
         `FILE: ${filePath} (${lineCount} lines, YAML)`,
         '',
-        'STRUCTURE:',
     ];
+    // Add top-level section overview with line ranges
+    const yamlSections = parseYamlSections(content);
+    if (yamlSections.length > 0) {
+        lines.push('SECTIONS:');
+        for (const sec of yamlSections) {
+            lines.push(`  ${sec.heading}: [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
+        }
+        lines.push('');
+    }
+    lines.push('STRUCTURE:');
     const rawLines = content.split('\n');
     const roots = [];
     // Stack tracks parent nodes at each indent level
@@ -159,6 +186,8 @@ function summarizeYaml(filePath, content, lineCount) {
             formatYamlNode(root, lines, 1, 3); // max 3 levels deep
         }
     }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<key>") to load a specific section.`);
     return lines.join('\n');
 }
 function formatYamlNode(node, lines, depth, maxDepth) {
@@ -194,16 +223,17 @@ function summarizeMarkdown(filePath, content, lineCount) {
     const lines = [
         `FILE: ${filePath} (${lineCount} lines, Markdown)`,
         '',
-        'TABLE OF CONTENTS:',
     ];
-    // Extract headings
-    for (const line of content.split('\n')) {
-        const match = line.match(/^(#{1,6})\s+(.+)/);
-        if (match) {
-            const level = match[1].length;
-            const indent = '  '.repeat(level - 1);
-            lines.push(`${indent}${match[2]}`);
-        }
+    const sections = parseMarkdownSections(content);
+    if (sections.length === 0) {
+        lines.push('(No headings found)');
+        return lines.join('\n');
+    }
+    lines.push('SECTIONS:');
+    for (const sec of sections) {
+        const indent = '  '.repeat(sec.level);
+        const hashes = '#'.repeat(sec.level);
+        lines.push(`${indent}${hashes} ${sec.heading} [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
     }
     // Count code blocks
     const codeBlocks = (content.match(/```/g) || []).length / 2;
@@ -211,6 +241,9 @@ function summarizeMarkdown(filePath, content, lineCount) {
         lines.push('');
         lines.push(`Code blocks: ${Math.floor(codeBlocks)}`);
     }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<name>") to load a specific section.`);
+    lines.push(`      Use read_for_edit("${filePath}", section="<name>") for edit context.`);
     return lines.join('\n');
 }
 function summarizeToml(filePath, content, lineCount) {
@@ -228,4 +261,8 @@ function summarizeToml(filePath, content, lineCount) {
     }
     return lines.join('\n');
 }
+function summarizeCsv(filePath, content, lineCount) {
+    const outline = parseCsvOutline(content);
+    return formatCsvOutline(filePath, outline, lineCount);
+}
 //# sourceMappingURL=non-code.js.map

package/dist/handlers/read-for-edit.d.ts

@@ -11,6 +11,7 @@ export interface ReadForEditArgs {
     include_callers?: boolean;
     include_tests?: boolean;
     include_changes?: boolean;
+    section?: string;
 }
 export declare function handleReadForEdit(args: ReadForEditArgs, projectRoot: string, symbolResolver: SymbolResolver, fileCache: FileCache, contextRegistry: ContextRegistry, astIndex: AstIndexClient, options?: {
     actionableHints?: boolean;

package/dist/handlers/read-for-edit.js

@@ -2,7 +2,11 @@ import { readFile, stat, access } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
-import { relative, join } from 'node:path';
+import { relative, join, extname } from 'node:path';
+import { parseMarkdownSections, findSection, extractSectionContent } from './markdown-sections.js';
+import { parseYamlSections, findYamlSection, extractYamlSectionContent } from './yaml-sections.js';
+import { parseJsonSections, findJsonSection, extractJsonSectionContent } from './json-sections.js';
+import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent } from './csv-sections.js';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
 import { assessConfidence, formatConfidence } from '../core/confidence.js';
@@ -11,6 +15,108 @@ const DEFAULT_CONTEXT = 5;
 export async function handleReadForEdit(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex, options) {
     const absPath = resolveSafePath(projectRoot, args.path);
     const ctx = args.context ?? DEFAULT_CONTEXT;
+    // Section mode: markdown/YAML section extraction for edit
+    if (args.section) {
+        const ext = extname(absPath).toLowerCase();
+        const supportedExts = new Set(['.md', '.markdown', '.yaml', '.yml', '.json', '.csv']);
+        if (!supportedExts.has(ext)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `"section" parameter only works with Markdown, YAML, or JSON files. Got: ${ext}. Use "symbol" for code files.`,
+                    }],
+            };
+        }
+        const fileContent = await readFile(absPath, 'utf-8');
+        const fileLines = fileContent.split('\n');
+        // Cache file in fileCache for read_diff baseline
+        if (!fileCache.get(absPath)) {
+            const fileStat = await stat(absPath);
+            const hash = createHash('sha256').update(fileContent).digest('hex');
+            const language = ext === '.csv' ? 'csv' : ext === '.json' ? 'json' : (ext === '.md' || ext === '.markdown') ? 'markdown' : 'yaml';
+            fileCache.set(absPath, {
+                structure: { path: absPath, language, meta: { lines: fileLines.length, bytes: fileContent.length, lastModified: fileStat.mtimeMs, contentHash: hash }, imports: [], exports: [], symbols: [] },
+                content: fileContent, lines: fileLines, mtime: fileStat.mtimeMs, hash, lastAccess: Date.now(),
+            });
+        }
+        let sectionResult = null;
+        if (ext === '.md' || ext === '.markdown') {
+            const sections = parseMarkdownSections(fileContent);
+            const section = findSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            const hashes = '#'.repeat(section.level);
+            sectionResult = { ...section, rawContent: extractSectionContent(fileLines, section), label: `${hashes} ${section.heading}` };
+        }
+        else if (ext === '.yaml' || ext === '.yml') {
+            const sections = parseYamlSections(fileContent);
+            const section = findYamlSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractYamlSectionContent(fileLines, section), label: section.heading };
+        }
+        else if (ext === '.json') {
+            const sections = parseJsonSections(fileContent);
+            const section = findJsonSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractJsonSectionContent(fileLines, section), label: section.heading };
+        }
+        else if (ext === '.csv') {
+            const outline = parseCsvOutline(fileContent);
+            const section = parseCsvSectionSpec(args.section, outline.rowCount);
+            if (!section) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Invalid section "${args.section}" for CSV. Use: rows:1-50 or row:5\nTotal rows: ${outline.rowCount}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractCsvSectionContent(fileLines, section), label: section.heading };
+        }
+        if (!sectionResult) {
+            return { content: [{ type: 'text', text: `Unsupported file type: ${ext}` }] };
+        }
+        const outputLines = [
+            `FILE: ${args.path}`,
+            `EDIT SECTION: ${sectionResult.label} [L${sectionResult.startLine}-${sectionResult.endLine}] (${sectionResult.lineCount} lines)`,
+            '',
+            sectionResult.rawContent,
+            '',
+            `AFTER EDIT: Use read_diff("${args.path}") to verify changes (90% cheaper than re-reading).`,
+        ];
+        const output = outputLines.join('\n');
+        const tokens = estimateTokens(output);
+        contextRegistry.trackLoad(absPath, {
+            type: 'range',
+            startLine: sectionResult.startLine,
+            endLine: sectionResult.endLine,
+            tokens,
+        });
+        return { content: [{ type: 'text', text: output }] };
+    }
     // Get file content — also cache for read_diff baseline
     const cached = fileCache.get(absPath);
     let lines;

package/dist/handlers/read-section.d.ts

@@ -0,0 +1,12 @@
+import type { ContextRegistry } from '../core/context-registry.js';
+export interface ReadSectionArgs {
+    path: string;
+    heading: string;
+}
+export declare function handleReadSection(args: ReadSectionArgs, projectRoot: string, contextRegistry: ContextRegistry): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=read-section.d.ts.map

package/dist/handlers/read-section.js

@@ -0,0 +1,96 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+import { estimateTokens } from '../core/token-estimator.js';
+import { resolveSafePath } from '../core/validation.js';
+import { parseMarkdownSections, findSection, extractSectionContent } from './markdown-sections.js';
+import { parseYamlSections, findYamlSection, extractYamlSectionContent } from './yaml-sections.js';
+import { parseJsonSections, findJsonSection, extractJsonSectionContent } from './json-sections.js';
+import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent } from './csv-sections.js';
+export async function handleReadSection(args, projectRoot, contextRegistry) {
+    const absPath = resolveSafePath(projectRoot, args.path);
+    const ext = extname(absPath).toLowerCase();
+    const content = await readFile(absPath, 'utf-8');
+    const lines = content.split('\n');
+    // Dispatch to format-specific parser
+    let sectionData = null;
+    if (ext === '.md' || ext === '.markdown') {
+        const sections = parseMarkdownSections(content);
+        const section = findSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        const hashes = '#'.repeat(section.level);
+        sectionData = { ...section, content: extractSectionContent(lines, section), label: `${hashes} ${section.heading}` };
+    }
+    else if (ext === '.yaml' || ext === '.yml') {
+        const sections = parseYamlSections(content);
+        const section = findYamlSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractYamlSectionContent(lines, section), label: section.heading };
+    }
+    else if (ext === '.json') {
+        const sections = parseJsonSections(content);
+        const section = findJsonSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractJsonSectionContent(lines, section), label: section.heading };
+    }
+    else if (ext === '.csv') {
+        const outline = parseCsvOutline(content);
+        const section = parseCsvSectionSpec(args.heading, outline.rowCount);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Invalid section spec "${args.heading}" for CSV. Use format: rows:1-50 or row:5\nTotal rows: ${outline.rowCount}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractCsvSectionContent(lines, section), label: section.heading };
+    }
+    else {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `read_section supports: .md, .yaml, .yml, .json, .csv. Got: ${ext}`,
+                }],
+        };
+    }
+    const outputLines = [
+        `FILE: ${args.path}`,
+        `SECTION: ${sectionData.label} [L${sectionData.startLine}-${sectionData.endLine}] (${sectionData.lineCount} lines)`,
+        '',
+        sectionData.content,
+        '',
+        `HINT: Use read_for_edit("${args.path}", section="${sectionData.heading}") for edit context.`,
+        'CONTEXT TRACKED.',
+    ];
+    const output = outputLines.join('\n');
+    const tokens = estimateTokens(output);
+    contextRegistry.trackLoad(absPath, {
+        type: 'range',
+        startLine: sectionData.startLine,
+        endLine: sectionData.endLine,
+        tokens,
+    });
+    return { content: [{ type: 'text', text: output }] };
+}
+//# sourceMappingURL=read-section.js.map

package/dist/handlers/session-snapshot.d.ts

@@ -0,0 +1,14 @@
+export interface SessionSnapshotArgs {
+    goal: string;
+    confirmed?: string[];
+    files?: string[];
+    blocked?: string;
+    next?: string;
+}
+export declare function handleSessionSnapshot(args: SessionSnapshotArgs): {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+};
+//# sourceMappingURL=session-snapshot.d.ts.map

package/dist/handlers/session-snapshot.js

@@ -0,0 +1,22 @@
+export function handleSessionSnapshot(args) {
+    const lines = ['## Session State'];
+    lines.push(`**Goal:** ${args.goal}`);
+    if (args.confirmed?.length) {
+        lines.push('**Confirmed:**');
+        for (const item of args.confirmed) {
+            lines.push(`- ${item}`);
+        }
+    }
+    if (args.files?.length) {
+        lines.push(`**Files:** ${args.files.join(', ')}`);
+    }
+    if (args.blocked) {
+        lines.push(`**Blocked:** ${args.blocked}`);
+    }
+    if (args.next) {
+        lines.push(`**Next:** ${args.next}`);
+    }
+    const text = lines.join('\n');
+    return { content: [{ type: 'text', text }] };
+}
+//# sourceMappingURL=session-snapshot.js.map

package/dist/handlers/smart-read-many.d.ts

@@ -4,6 +4,7 @@ import type { ContextRegistry } from '../core/context-registry.js';
 import type { TokenPilotConfig } from '../types.js';
 export interface SmartReadManyArgs {
     paths: string[];
+    max_tokens?: number;
 }
 export declare function handleSmartReadMany(args: SmartReadManyArgs, projectRoot: string, astIndex: AstIndexClient, fileCache: FileCache, contextRegistry: ContextRegistry, config: TokenPilotConfig): Promise<{
     content: Array<{

package/dist/handlers/smart-read-many.js

@@ -32,7 +32,7 @@ export async function handleSmartReadMany(args, projectRoot, astIndex, fileCache
                 const fullTokens = await estimateFullFileTokens(projectRoot, path);
                 return { path, text: reminderText + `\nFor full re-read: smart_read("${path}")`, fullTokens };
             }
-            const result = await handleSmartRead({ path }, projectRoot, astIndex, fileCache, contextRegistry, config);
+            const result = await handleSmartRead({ path, max_tokens: args.max_tokens }, projectRoot, astIndex, fileCache, contextRegistry, config);
             const text = result.content[0]?.text ?? '';
             const fullTokens = await estimateFullFileTokens(projectRoot, path);
             return { path, text, fullTokens };

package/dist/handlers/smart-read.d.ts

@@ -9,6 +9,7 @@ export interface SmartReadArgs {
     show_references?: boolean;
     depth?: number;
     scope?: 'full' | 'nav' | 'exports';
+    max_tokens?: number;
 }
 export declare function handleSmartRead(args: SmartReadArgs, projectRoot: string, astIndex: AstIndexClient, fileCache: FileCache, contextRegistry: ContextRegistry, config: TokenPilotConfig): Promise<{
     content: Array<{

package/dist/handlers/smart-read.js

@@ -28,31 +28,35 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
     if (lines.length <= config.smartRead.smallFileThreshold) {
         const hash = createHash('sha256').update(content).digest('hex');
         const tokens = estimateTokens(content);
-        contextRegistry.trackLoad(absPath, {
-            type: 'full',
-            startLine: 1,
-            endLine: lines.length,
-            tokens,
-        });
-        contextRegistry.setContentHash(absPath, hash);
-        // Cache for read_diff baseline (so read_diff works after external edits)
-        if (!fileCache.get(absPath)) {
-            const fileStat = await stat(absPath);
-            fileCache.set(absPath, {
-                structure: {
-                    path: absPath, language: 'unknown',
-                    meta: { lines: lines.length, bytes: content.length, lastModified: fileStat.mtimeMs, contentHash: hash },
-                    imports: [], exports: [], symbols: [],
-                },
-                content, lines, mtime: fileStat.mtimeMs, hash, lastAccess: Date.now(),
+        // Budget check: if full content exceeds max_tokens, skip pass-through and use outline path
+        if (!args.max_tokens || tokens <= args.max_tokens) {
+            contextRegistry.trackLoad(absPath, {
+                type: 'full',
+                startLine: 1,
+                endLine: lines.length,
+                tokens,
             });
+            contextRegistry.setContentHash(absPath, hash);
+            // Cache for read_diff baseline (so read_diff works after external edits)
+            if (!fileCache.get(absPath)) {
+                const fileStat = await stat(absPath);
+                fileCache.set(absPath, {
+                    structure: {
+                        path: absPath, language: 'unknown',
+                        meta: { lines: lines.length, bytes: content.length, lastModified: fileStat.mtimeMs, contentHash: hash },
+                        imports: [], exports: [], symbols: [],
+                    },
+                    content, lines, mtime: fileStat.mtimeMs, hash, lastAccess: Date.now(),
+                });
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `FILE: ${args.path} (${lines.length} lines — returned in full, below threshold)\n\n${content}`,
+                    }],
+            };
         }
-        return {
-            content: [{
-                    type: 'text',
-                    text: `FILE: ${args.path} (${lines.length} lines — returned in full, below threshold)\n\n${content}`,
-                }],
-        };
+        // else: fall through to outline path even for small files
     }
     // 3. Check cache
     let cached = fileCache.get(absPath);
@@ -174,7 +178,7 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
     // 6b. Adaptive fallback: if outline is not significantly smaller than raw, return raw
     const structureTokens = estimateTokens(output);
     const fullTokens = estimateTokens(content);
-    if (structureTokens >= fullTokens * 0.7) {
+    if (structureTokens >= fullTokens * 0.7 && (!args.max_tokens || fullTokens <= args.max_tokens)) {
         contextRegistry.trackLoad(absPath, {
             type: 'full',
             startLine: 1,
@@ -192,11 +196,30 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
                 }],
         };
     }
-    // 7. Add token savings
+    // 7. Budget enforcement: if outline exceeds max_tokens, return compact version
+    if (args.max_tokens && structureTokens > args.max_tokens) {
+        const symbols = cached.structure.symbols;
+        const compactLines = [
+            `FILE: ${args.path} (${lines.length} lines — compact, budget: ${args.max_tokens} tokens)`,
+            `Imports: ${cached.structure.imports?.length ?? 0} | Exports: ${cached.structure.exports?.length ?? 0} | Symbols: ${symbols.length}`,
+            '',
+        ];
+        for (const sym of symbols) {
+            compactLines.push(`  ${sym.kind} ${sym.name} [L${sym.location.startLine}-${sym.location.endLine}]`);
+        }
+        compactLines.push('', `Use read_symbol("${args.path}", "<name>") to drill into any symbol.`);
+        const compactText = compactLines.join('\n');
+        const compactTokens = estimateTokens(compactText);
+        contextRegistry.trackLoad(absPath, { type: 'structure', startLine: 1, endLine: cached.structure.meta.lines, tokens: compactTokens });
+        contextRegistry.setContentHash(absPath, cached.hash);
+        contextRegistry.trackStructureSymbols(absPath, symbols.map(s => s.name));
+        return { content: [{ type: 'text', text: compactText }] };
+    }
+    // 8. Add token savings
     const savings = config.display.showTokenSavings
         ? '\n' + formatSavings(structureTokens, fullTokens)
         : '';
-    // 8. Track
+    // 9. Track
     contextRegistry.trackLoad(absPath, {
         type: 'structure',
         startLine: 1,
@@ -205,7 +228,7 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
     });
     contextRegistry.setContentHash(absPath, cached.hash);
     contextRegistry.trackStructureSymbols(absPath, cached.structure.symbols.map(s => s.name));
-    // 9. Confidence metadata
+    // 10. Confidence metadata
     const confidenceMeta = assessConfidence({
         symbolResolved: (cached.structure.symbols?.length ?? 0) > 0,
         fullFile: false,

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

@@ -0,0 +1,17 @@
+/**
+ * YAML section parser — parses top-level keys with line ranges.
+ */
+export interface YamlSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse YAML into sections based on top-level keys.
+ * A top-level key is a key at indent level 0.
+ */
+export declare function parseYamlSections(content: string): YamlSection[];
+export declare function findYamlSection(sections: YamlSection[], heading: string): YamlSection | undefined;
+export declare function extractYamlSectionContent(lines: string[], section: YamlSection): string;
+//# sourceMappingURL=yaml-sections.d.ts.map

package/dist/handlers/yaml-sections.js

@@ -0,0 +1,46 @@
+/**
+ * YAML section parser — parses top-level keys with line ranges.
+ */
+/**
+ * Parse YAML into sections based on top-level keys.
+ * A top-level key is a key at indent level 0.
+ */
+export function parseYamlSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    const topKeys = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip comments and empty lines
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        // Top-level key: starts at column 0, has format "key:" or "key: value"
+        const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_.-]*):/);
+        if (match) {
+            topKeys.push({ key: match[1], line: i + 1 });
+        }
+    }
+    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;
+        sections.push({
+            heading: topKeys[i].key,
+            startLine: start,
+            endLine: end,
+            lineCount: end - start + 1,
+        });
+    }
+    return sections;
+}
+export function findYamlSection(sections, heading) {
+    const normalized = heading.trim().toLowerCase().replace(/:$/, '');
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractYamlSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=yaml-sections.js.map