lat.md 0.5.0 → 0.7.0

package/dist/src/lattice.js

@@ -31,6 +31,10 @@ export function findLatticeDir(from) {
         dir = parent;
     }
 }
+export function findProjectRoot(from) {
+    const latDir = findLatticeDir(from);
+    return latDir ? dirname(latDir) : null;
+}
 export async function listLatticeFiles(latticeDir) {
     const entries = await walkEntries(latticeDir);
     return entries
@@ -64,11 +68,14 @@ function lastLine(content) {
     // If trailing newline, count doesn't include empty last line
     return lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
 }
-export function parseSections(filePath, content, latticeDir) {
+export function parseSections(filePath, content, projectRoot) {
     const tree = parse(stripFrontmatter(content));
-    const file = latticeDir
-        ? relative(latticeDir, filePath).replace(/\.md$/, '')
+    const file = projectRoot
+        ? relative(projectRoot, filePath).replace(/\.md$/, '')
         : basename(filePath, '.md');
+    const sectionFilePath = projectRoot
+        ? relative(projectRoot, filePath)
+        : basename(filePath);
     const roots = [];
     const stack = [];
     const flat = [];
@@ -87,10 +94,11 @@ export function parseSections(filePath, content, latticeDir) {
             heading,
             depth,
             file,
+            filePath: sectionFilePath,
             children: [],
             startLine,
             endLine: 0,
-            body: '',
+            firstParagraph: '',
         };
         if (parent) {
             parent.children.push(section);
@@ -111,7 +119,7 @@ export function parseSections(filePath, content, latticeDir) {
             flat[i].endLine = fileLastLine;
         }
     }
-    // Extract body: first paragraph after each heading
+    // Extract firstParagraph: first paragraph after each heading
     const children = tree.children;
     let headingIdx = 0;
     for (let i = 0; i < children.length; i++) {
@@ -122,7 +130,7 @@ export function parseSections(filePath, content, latticeDir) {
                 if (children[j].type === 'heading')
                     break;
                 if (children[j].type === 'paragraph') {
-                    flat[headingIdx].body = inlineText(children[j]);
+                    flat[headingIdx].firstParagraph = inlineText(children[j]);
                     break;
                 }
             }
@@ -132,11 +140,12 @@ export function parseSections(filePath, content, latticeDir) {
     return roots;
 }
 export async function loadAllSections(latticeDir) {
+    const projectRoot = dirname(latticeDir);
     const files = await listLatticeFiles(latticeDir);
     const all = [];
     for (const file of files) {
         const content = await readFile(file, 'utf-8');
-        all.push(...parseSections(file, content, latticeDir));
+        all.push(...parseSections(file, content, projectRoot));
     }
     return all;
 }
@@ -180,18 +189,26 @@ function tailSegments(id) {
     return tails;
 }
 /**
- * Build an index mapping bare file stems to their full vault-relative paths.
- * Used by resolveRef to allow short references when a stem is unambiguous.
+ * Build an index mapping path suffixes to their full vault-relative paths.
+ * Used by resolveRef to allow short references when a suffix is unambiguous.
+ *
+ * For a file like `lat.md/guides/setup`, indexes both `guides/setup` and `setup`.
+ * This ensures backward-compatible short refs after the vault root moved to the
+ * project root (so section IDs now include the `lat.md/` prefix).
  */
 export function buildFileIndex(sections) {
     const flat = flattenSections(sections);
     const index = new Map();
     for (const s of flat) {
-        const stem = s.file.includes('/') ? s.file.split('/').pop() : null;
-        if (stem) {
-            if (!index.has(stem))
-                index.set(stem, new Set());
-            index.get(stem).add(s.file);
+        const parts = s.file.split('/');
+        // Index all trailing path suffixes (excluding the full path itself,
+        // which is handled by exact match). Keys are lowercase for
+        // case-insensitive lookup.
+        for (let i = 1; i < parts.length; i++) {
+            const suffix = parts.slice(i).join('/').toLowerCase();
+            if (!index.has(suffix))
+                index.set(suffix, new Set());
+            index.get(suffix).add(s.file);
         }
     }
     const result = new Map();
@@ -219,8 +236,10 @@ export function resolveRef(target, sectionIds, fileIndex) {
     const filePart = hashIdx === -1 ? target : target.slice(0, hashIdx);
     const rest = hashIdx === -1 ? '' : target.slice(hashIdx);
     // Try resolving the file part: either it's a full path or a bare stem
-    const filePaths = fileIndex.has(filePart)
-        ? fileIndex.get(filePart)
+    // File index keys are lowercase for case-insensitive lookup.
+    const lcFilePart = filePart.toLowerCase();
+    const filePaths = fileIndex.has(lcFilePart)
+        ? fileIndex.get(lcFilePart)
         : [filePart];
     if (filePaths.length === 1) {
         const fp = filePaths[0];
@@ -288,27 +307,44 @@ export function findSections(sections, query) {
     }));
     if (exactMatches.length > 0 && isFullPath)
         return exactMatches;
+    // Build file index early — used by both tier 1a and 1b
+    const fileIndex = buildFileIndex(sections);
     // Tier 1a: bare name matches file — return root sections of that file
+    // Also checks via file index (e.g. "dev-process" → "lat.md/dev-process")
     if (!isFullPath && exactMatches.length === 0) {
-        const fileRoots = flat.filter((s) => s.file.toLowerCase() === q && !s.id.includes('#', s.file.length + 1));
-        if (fileRoots.length > 0) {
-            return fileRoots.map((s) => ({
-                section: s,
-                reason: 'exact match',
-            }));
+        const matchFiles = new Set();
+        // Direct match
+        for (const s of flat) {
+            if (s.file.toLowerCase() === q &&
+                !s.id.includes('#', s.file.length + 1)) {
+                matchFiles.add(s.file);
+            }
+        }
+        // File index expansion (keys are lowercase)
+        const indexPaths = fileIndex.get(q) ?? [];
+        for (const p of indexPaths) {
+            matchFiles.add(p);
+        }
+        if (matchFiles.size > 0) {
+            const fileRoots = flat.filter((s) => matchFiles.has(s.file) && !s.id.includes('#', s.file.length + 1));
+            if (fileRoots.length > 0) {
+                return fileRoots.map((s) => ({
+                    section: s,
+                    reason: 'exact match',
+                }));
+            }
         }
     }
     // Tier 1b: file stem expansion
     // For bare names: "locate" → matches root section of "tests/locate.md"
     // For paths with #: "setup#Install" → expands to "guides/setup#Install"
-    const fileIndex = buildFileIndex(sections);
     const stemMatches = [];
     if (isFullPath) {
         // Expand file stem in the file part of the query
         const hashIdx = normalized.indexOf('#');
         const filePart = normalized.slice(0, hashIdx);
         const rest = normalized.slice(hashIdx);
-        const stemPaths = fileIndex.get(filePart) ?? [];
+        const stemPaths = fileIndex.get(filePart.toLowerCase()) ?? [];
         // Also try filePart as a direct file path (for root-level files not in index)
         const allPaths = stemPaths.length > 0 ? stemPaths : filePart ? [filePart] : [];
         for (const p of allPaths) {
@@ -343,8 +379,8 @@ export function findSections(sections, query) {
             return [...exactMatches, ...stemMatches];
     }
     else {
-        // Bare name: match root sections of files via stem index
-        const paths = fileIndex.get(normalized) ?? [];
+        // Bare name: match root sections of files via stem index (keys lowercase)
+        const paths = fileIndex.get(q) ?? [];
         for (const p of paths) {
             for (const s of flat) {
                 if (exact.includes(s))
@@ -373,24 +409,37 @@ export function findSections(sections, query) {
             .map((s) => ({ section: s, reason: 'section name match' }));
     // Tier 2b: subsequence match — query segments are a subsequence of section id segments
     // e.g. "Markdown#Resolution Rules" matches "markdown#Wiki Links#Resolution Rules"
+    // Also tries expanding the file part via the file index for short refs.
     const seenSub = new Set([...seen, ...subsection.map((m) => m.section.id)]);
     const qParts = q.split('#');
+    // Build query variants: original + file-index-expanded forms
+    const qVariants = [qParts];
+    if (qParts.length >= 2) {
+        const expanded = fileIndex.get(qParts[0]);
+        if (expanded) {
+            for (const exp of expanded) {
+                qVariants.push([exp.toLowerCase(), ...qParts.slice(1)]);
+            }
+        }
+    }
     const subsequence = qParts.length >= 2
         ? flat
             .filter((s) => {
             if (seenSub.has(s.id))
                 return false;
             const sParts = s.id.toLowerCase().split('#');
-            if (sParts.length <= qParts.length)
+            return qVariants.some((variant) => {
+                if (sParts.length <= variant.length)
+                    return false;
+                let qi = 0;
+                for (const sp of sParts) {
+                    if (sp === variant[qi])
+                        qi++;
+                    if (qi === variant.length)
+                        return true;
+                }
                 return false;
-            let qi = 0;
-            for (const sp of sParts) {
-                if (sp === qParts[qi])
-                    qi++;
-                if (qi === qParts.length)
-                    return true;
-            }
-            return false;
+            });
         })
             .map((s) => {
             const skipped = s.id.split('#').length - qParts.length;
@@ -472,10 +521,10 @@ export function findSections(sections, query) {
         ...fuzzyMatches,
     ];
 }
-export function extractRefs(filePath, content, latticeDir) {
+export function extractRefs(filePath, content, projectRoot) {
     const tree = parse(stripFrontmatter(content));
-    const file = latticeDir
-        ? relative(latticeDir, filePath).replace(/\.md$/, '')
+    const file = projectRoot
+        ? relative(projectRoot, filePath).replace(/\.md$/, '')
         : basename(filePath, '.md');
     const refs = [];
     // Build a flat list of sections to determine enclosing section for each wiki link

package/dist/src/mcp/server.js

@@ -1,33 +1,18 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { relative } from 'node:path';
-import { findLatticeDir, loadAllSections, findSections, flattenSections, buildFileIndex, resolveRef, extractRefs, listLatticeFiles, } from '../lattice.js';
-import { scanCodeRefs } from '../code-refs.js';
-import { checkMd, checkCodeRefs, checkIndex } from '../cli/check.js';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-function formatSection(s, latDir) {
-    const relPath = relative(process.cwd(), latDir + '/' + s.file + '.md');
-    const kind = s.id.includes('#') ? 'Section' : 'File';
-    const lines = [
-        `* ${kind}: [[${s.id}]]`,
-        `  Defined in ${relPath}:${s.startLine}-${s.endLine}`,
-    ];
-    if (s.body) {
-        const truncated = s.body.length > 200 ? s.body.slice(0, 200) + '...' : s.body;
-        lines.push('', `  > ${truncated}`);
-    }
-    return lines.join('\n');
-}
-function formatMatches(header, matches, latDir) {
-    const lines = [header, ''];
-    for (let i = 0; i < matches.length; i++) {
-        if (i > 0)
-            lines.push('');
-        lines.push(formatSection(matches[i].section, latDir) + ` (${matches[i].reason})`);
-    }
-    return lines.join('\n');
+import { dirname } from 'node:path';
+import { findLatticeDir } from '../lattice.js';
+import { plainStyler } from '../context.js';
+import { locateCommand } from '../cli/locate.js';
+import { sectionCommand } from '../cli/section.js';
+import { searchCommand } from '../cli/search.js';
+import { expandCommand } from '../cli/expand.js';
+import { checkAllCommand } from '../cli/check.js';
+import { refsCommand } from '../cli/refs.js';
+function toMcp(result) {
+    const content = [{ type: 'text', text: result.output }];
+    return result.isError ? { content, isError: true } : { content };
 }
 export async function startMcpServer() {
     const latDir = findLatticeDir();
@@ -35,32 +20,21 @@ export async function startMcpServer() {
         process.stderr.write('No lat.md directory found\n');
         process.exit(1);
     }
+    const projectRoot = dirname(latDir);
+    const ctx = {
+        latDir,
+        projectRoot,
+        styler: plainStyler,
+        mode: 'mcp',
+    };
     const server = new McpServer({
         name: 'lat',
         version: '1.0.0',
     });
-    server.tool('lat_locate', 'Find sections by name (exact, fuzzy, subsequence matching)', { query: z.string().describe('Section name or id to search for') }, async ({ query }) => {
-        const sections = await loadAllSections(latDir);
-        const matches = findSections(sections, query.replace(/^\[\[|\]\]$/g, ''));
-        if (matches.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No sections matching "${query}"`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: formatMatches(`Sections matching "${query}":`, matches, latDir),
-                },
-            ],
-        };
-    });
+    server.tool('lat_locate', 'Find sections by name (exact, fuzzy, subsequence matching)', { query: z.string().describe('Section name or id to search for') }, async ({ query }) => toMcp(await locateCommand(ctx, query)));
+    server.tool('lat_section', 'Show a section with its content, outgoing wiki link targets, and incoming references', {
+        query: z.string().describe('Section id to look up (short or full form)'),
+    }, async ({ query }) => toMcp(await sectionCommand(ctx, query)));
     server.tool('lat_search', 'Semantic search across lat.md sections using embeddings', {
         query: z.string().describe('Search query in natural language'),
         limit: z
@@ -68,150 +42,9 @@ export async function startMcpServer() {
             .optional()
             .default(5)
             .describe('Max results (default 5)'),
-    }, async ({ query, limit }) => {
-        const { getLlmKey } = await import('../config.js');
-        let key;
-        try {
-            key = getLlmKey();
-        }
-        catch (err) {
-            return {
-                content: [{ type: 'text', text: err.message }],
-                isError: true,
-            };
-        }
-        if (!key) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'No LLM key found. Provide a key via LAT_LLM_KEY, LAT_LLM_KEY_FILE, LAT_LLM_KEY_HELPER, or run `lat init`.',
-                    },
-                ],
-                isError: true,
-            };
-        }
-        const { detectProvider } = await import('../search/provider.js');
-        const { openDb, ensureSchema, closeDb } = await import('../search/db.js');
-        const { indexSections } = await import('../search/index.js');
-        const { searchSections } = await import('../search/search.js');
-        const provider = detectProvider(key);
-        const db = openDb(latDir);
-        try {
-            await ensureSchema(db, provider.dimensions);
-            await indexSections(latDir, db, provider, key);
-            const results = await searchSections(db, query, provider, key, limit);
-            if (results.length === 0) {
-                return {
-                    content: [{ type: 'text', text: 'No results found.' }],
-                };
-            }
-            const allSections = await loadAllSections(latDir);
-            const flat = flattenSections(allSections);
-            const byId = new Map(flat.map((s) => [s.id, s]));
-            const matched = results
-                .map((r) => byId.get(r.id))
-                .filter((s) => !!s)
-                .map((s) => ({ section: s, reason: 'semantic match' }));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: formatMatches(`Search results for "${query}":`, matched, latDir),
-                    },
-                ],
-            };
-        }
-        finally {
-            await closeDb(db);
-        }
-    });
-    server.tool('lat_prompt', 'Expand [[refs]] in text to resolved lat.md section paths with context', { text: z.string().describe('Text containing [[refs]] to expand') }, async ({ text }) => {
-        const WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
-        const allSections = await loadAllSections(latDir);
-        const refs = [...text.matchAll(WIKI_LINK_RE)];
-        if (refs.length === 0) {
-            return {
-                content: [{ type: 'text', text }],
-            };
-        }
-        const resolved = new Map();
-        const errors = [];
-        for (const match of refs) {
-            const target = match[1];
-            if (resolved.has(target))
-                continue;
-            const matches = findSections(allSections, target);
-            if (matches.length >= 1) {
-                resolved.set(target, {
-                    target,
-                    best: matches[0],
-                    alternatives: matches.slice(1),
-                });
-            }
-            else {
-                errors.push(`No section found for [[${target}]]`);
-            }
-        }
-        if (errors.length > 0) {
-            return {
-                content: [{ type: 'text', text: errors.join('\n') }],
-                isError: true,
-            };
-        }
-        let output = text.replace(WIKI_LINK_RE, (_match, target) => {
-            const ref = resolved.get(target);
-            return `[[${ref.best.section.id}]]`;
-        });
-        output += '\n\n<lat-context>\n';
-        for (const ref of resolved.values()) {
-            const isExact = ref.best.reason === 'exact match';
-            const all = isExact ? [ref.best] : [ref.best, ...ref.alternatives];
-            if (isExact) {
-                output += `* [[${ref.target}]] is referring to:\n`;
-            }
-            else {
-                output += `* [[${ref.target}]] might be referring to either of the following:\n`;
-            }
-            for (const m of all) {
-                const reason = isExact ? '' : ` (${m.reason})`;
-                const relPath = relative(process.cwd(), latDir + '/' + m.section.file + '.md');
-                output += `  * [[${m.section.id}]]${reason}\n`;
-                output += `    * ${relPath}:${m.section.startLine}-${m.section.endLine}\n`;
-                if (m.section.body) {
-                    output += `    * ${m.section.body}\n`;
-                }
-            }
-        }
-        output += '</lat-context>\n';
-        return {
-            content: [{ type: 'text', text: output }],
-        };
-    });
-    server.tool('lat_check', 'Validate all wiki links, code references, and directory indexes in lat.md', {}, async () => {
-        const md = await checkMd(latDir);
-        const code = await checkCodeRefs(latDir);
-        const indexErrors = await checkIndex(latDir);
-        const allErrors = [...md.errors, ...code.errors];
-        const lines = [];
-        for (const err of allErrors) {
-            lines.push(`${err.file}:${err.line}: ${err.message}`);
-        }
-        for (const err of indexErrors) {
-            lines.push(`${err.dir}: ${err.message}`);
-        }
-        const totalErrors = allErrors.length + indexErrors.length;
-        if (totalErrors === 0) {
-            return {
-                content: [{ type: 'text', text: 'All checks passed' }],
-            };
-        }
-        lines.push(`\n${totalErrors} error${totalErrors === 1 ? '' : 's'} found`);
-        return {
-            content: [{ type: 'text', text: lines.join('\n') }],
-            isError: true,
-        };
-    });
+    }, async ({ query, limit }) => toMcp(await searchCommand(ctx, query, { limit })));
+    server.tool('lat_expand', 'Expand [[refs]] in text to resolved lat.md section paths with context', { text: z.string().describe('Text containing [[refs]] to expand') }, async ({ text: input }) => toMcp(await expandCommand(ctx, input)));
+    server.tool('lat_check', 'Validate all wiki links, code references, and directory indexes in lat.md', {}, async () => toMcp(await checkAllCommand(ctx)));
     server.tool('lat_refs', 'Find sections that reference a given section via wiki links or @lat code comments', {
         query: z.string().describe('Section id to find references for'),
         scope: z
@@ -219,92 +52,7 @@ export async function startMcpServer() {
             .optional()
             .default('md')
             .describe('Where to search: md, code, or md+code'),
-    }, async ({ query, scope }) => {
-        const allSections = await loadAllSections(latDir);
-        const flat = flattenSections(allSections);
-        const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
-        const fileIndex = buildFileIndex(allSections);
-        const { resolved } = resolveRef(query, sectionIds, fileIndex);
-        const q = resolved.toLowerCase();
-        const exactMatch = flat.find((s) => s.id.toLowerCase() === q);
-        if (!exactMatch) {
-            const matches = findSections(allSections, query);
-            if (matches.length > 0) {
-                const suggestions = matches
-                    .map((m) => `  * ${m.section.id} (${m.reason})`)
-                    .join('\n');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `No exact section "${query}" found. Did you mean:\n${suggestions}`,
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No section matching "${query}"`,
-                    },
-                ],
-            };
-        }
-        const targetId = exactMatch.id.toLowerCase();
-        const mdMatches = [];
-        const codeLines = [];
-        if (scope === 'md' || scope === 'md+code') {
-            const files = await listLatticeFiles(latDir);
-            const matchingFromSections = new Set();
-            for (const file of files) {
-                const content = await readFile(file, 'utf-8');
-                const fileRefs = extractRefs(file, content, latDir);
-                for (const ref of fileRefs) {
-                    const { resolved: refResolved } = resolveRef(ref.target, sectionIds, fileIndex);
-                    if (refResolved.toLowerCase() === targetId) {
-                        matchingFromSections.add(ref.fromSection.toLowerCase());
-                    }
-                }
-            }
-            if (matchingFromSections.size > 0) {
-                const referrers = flat.filter((s) => matchingFromSections.has(s.id.toLowerCase()));
-                for (const s of referrers) {
-                    mdMatches.push({ section: s, reason: 'wiki link' });
-                }
-            }
-        }
-        if (scope === 'code' || scope === 'md+code') {
-            const projectRoot = join(latDir, '..');
-            const { refs: codeRefs } = await scanCodeRefs(projectRoot);
-            for (const ref of codeRefs) {
-                const { resolved: codeResolved } = resolveRef(ref.target, sectionIds, fileIndex);
-                if (codeResolved.toLowerCase() === targetId) {
-                    codeLines.push(`${ref.file}:${ref.line}`);
-                }
-            }
-        }
-        if (mdMatches.length === 0 && codeLines.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No references to "${exactMatch.id}" found`,
-                    },
-                ],
-            };
-        }
-        const parts = [];
-        if (mdMatches.length > 0) {
-            parts.push(formatMatches(`References to "${exactMatch.id}":`, mdMatches, latDir));
-        }
-        if (codeLines.length > 0) {
-            parts.push('Code references:\n' + codeLines.map((l) => `* ${l}`).join('\n'));
-        }
-        return {
-            content: [{ type: 'text', text: parts.join('\n\n') }],
-        };
-    });
+    }, async ({ query, scope }) => toMcp(await refsCommand(ctx, query, scope)));
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/src/search/index.js

@@ -1,24 +1,25 @@
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { loadAllSections, flattenSections } from '../lattice.js';
 import { embed } from './embeddings.js';
 function hashContent(text) {
     return createHash('sha256').update(text).digest('hex');
 }
-async function sectionContent(section, latDir) {
-    const filePath = join(latDir, section.file + '.md');
+async function sectionContent(section, projectRoot) {
+    const filePath = join(projectRoot, section.filePath);
     const content = await readFile(filePath, 'utf-8');
     const lines = content.split('\n');
     return lines.slice(section.startLine - 1, section.endLine).join('\n');
 }
 export async function indexSections(latDir, db, provider, key) {
+    const projectRoot = dirname(latDir);
     const allSections = await loadAllSections(latDir);
     const flat = flattenSections(allSections);
     // Build current state: id -> { section, content, hash }
     const current = new Map();
     for (const s of flat) {
-        const text = await sectionContent(s, latDir);
+        const text = await sectionContent(s, projectRoot);
         current.set(s.id, { section: s, content: text, hash: hashContent(text) });
     }
     // Get existing hashes from DB

package/dist/src/source-parser.d.ts

@@ -0,0 +1,23 @@
+import type { Section } from './lattice.js';
+export type SourceSymbol = {
+    name: string;
+    kind: 'function' | 'class' | 'const' | 'type' | 'interface' | 'method' | 'variable';
+    parent?: string;
+    startLine: number;
+    endLine: number;
+    signature: string;
+};
+export declare function parseSourceSymbols(filePath: string, content: string): Promise<SourceSymbol[]>;
+/**
+ * Check whether a source file path (relative to projectRoot) has a given symbol.
+ * Used by lat check to validate source code wiki links lazily.
+ */
+export declare function resolveSourceSymbol(filePath: string, symbolPath: string, projectRoot: string): Promise<{
+    found: boolean;
+    symbols: SourceSymbol[];
+    error?: string;
+}>;
+/**
+ * Convert source symbols to Section objects for uniform handling.
+ */
+export declare function sourceSymbolsToSections(symbols: SourceSymbol[], filePath: string): Section[];