@jsleekr/graft 5.7.0

package/dist/lsp/features/hover.js

@@ -0,0 +1,88 @@
+import { MarkupKind } from 'vscode-languageserver/node';
+import { BUILTIN_FUNCTIONS } from '../../parser/ast.js';
+import { formatExpr } from '../../format.js';
+export const KEYWORD_DOCS = {
+    context: 'Declares a context schema with typed fields and a max_tokens budget.\n\n```graft\ncontext Name(max_tokens: 1k) {\n  field: Type\n}\n```',
+    node: 'Declares a processing node with model, budget, reads, writes, and produces.\n\n```graft\nnode Name(model: sonnet, budget: 5k/2k) {\n  reads: [ContextName]\n  produces Output { field: Type }\n}\n```',
+    memory: 'Declares persistent memory with typed fields and storage backend.\n\n```graft\nmemory Name(max_tokens: 2k, storage: file) {\n  field: Type\n}\n```',
+    graph: 'Declares an execution graph connecting nodes in a flow.\n\n```graft\ngraph Name(input: In, output: Out, budget: 10k) {\n  Start -> Middle -> done\n}\n```',
+    edge: 'Declares a data transform between nodes.\n\n```graft\nedge Source -> Target | select(field) | compact\n```',
+    import: 'Imports contexts and nodes from another .gft file.\n\n```graft\nimport { Name } from "./lib.gft"\n```',
+    reads: 'Specifies which contexts, produces, or memories a node reads from.\n\n```graft\nreads: [ContextName, Produces.field]\n```',
+    writes: 'Specifies which memories a node writes to.\n\n```graft\nwrites: [MemoryName.field]\n```',
+    produces: 'Declares the output schema of a node.\n\n```graft\nproduces OutputName {\n  field: Type\n}\n```',
+    model: 'Specifies the LLM model alias for a node.\n\nAliases: sonnet, opus, haiku',
+    max_tokens: 'Sets the maximum token budget for a context or memory.',
+    on_failure: 'Specifies failure handling strategy for a node.\n\nStrategies: retry(N), fallback(Node), skip, abort',
+    storage: 'Specifies the storage backend for a memory declaration.\n\nCurrently supported: file',
+    foreach: 'Iterates over a list field from a node\'s output.\n\n```graft\nforeach(Node.output.field as item, max_iterations: 5) {\n  Step1 -> Step2\n}\n```',
+    parallel: 'Executes multiple nodes concurrently.\n\n```graft\nparallel { Node1 Node2 Node3 }\n```',
+};
+export function getHoverInfo(word, index) {
+    const keywordDoc = KEYWORD_DOCS[word];
+    if (keywordDoc) {
+        return mkHover(keywordDoc);
+    }
+    const ctx = index.contextMap.get(word);
+    if (ctx) {
+        const fields = ctx.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+        return mkHover(`**context** ${ctx.name} (max_tokens: ${ctx.maxTokens})\n\`\`\`\n${fields}\n\`\`\``);
+    }
+    const node = index.nodeMap.get(word);
+    if (node) {
+        const reads = node.reads.map(r => {
+            if (!r.field)
+                return r.context;
+            return r.field.length === 1 ? `${r.context}.${r.field[0]}` : `${r.context}.{${r.field.join(', ')}}`;
+        }).join(', ');
+        const writes = node.writes.length > 0
+            ? `\nwrites: ${node.writes.map(w => w.field ? `${w.memory}.${w.field}` : w.memory).join(', ')}`
+            : '';
+        const producesFields = node.produces.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+        return mkHover(`**node** ${node.name}\n` +
+            `- model: ${node.model}\n` +
+            `- budget: ${node.budgetIn}/${node.budgetOut}\n` +
+            `- reads: ${reads}${writes}\n` +
+            `- produces: ${node.produces.name}\n\`\`\`\n${producesFields}\n\`\`\``);
+    }
+    const mem = index.memoryMap.get(word);
+    if (mem) {
+        const fields = mem.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+        return mkHover(`**memory** ${mem.name} (max_tokens: ${mem.maxTokens}, storage: ${mem.storage})\n\`\`\`\n${fields}\n\`\`\``);
+    }
+    // Built-in functions
+    if (word in BUILTIN_FUNCTIONS) {
+        const info = BUILTIN_FUNCTIONS[word];
+        return mkHover(`**${info.signature}**\n\n${info.description}`);
+    }
+    const producerNode = index.producesNodeMap.get(word);
+    if (producerNode) {
+        const fields = producerNode.produces.fields.map(f => `  ${f.name}: ${formatType(f.type)}`).join('\n');
+        return mkHover(`**produces** ${word} (from node ${producerNode.name})\n\`\`\`\n${fields}\n\`\`\``);
+    }
+    // Let binding variables
+    const letBinding = index.letBindingMap.get(word);
+    if (letBinding) {
+        const exprStr = formatExpr(letBinding.value);
+        return mkHover(`**let** ${word} = ${exprStr}\n\n(in graph ${letBinding.graphName})`);
+    }
+    return null;
+}
+export function formatType(type) {
+    switch (type.kind) {
+        case 'primitive': return type.name;
+        case 'primitive_range': return `Float(${type.min}..${type.max})`;
+        case 'list': return `List<${formatType(type.element)}>`;
+        case 'map': return `Map<${formatType(type.key)}, ${formatType(type.value)}>`;
+        case 'optional': return `${formatType(type.inner)}?`;
+        case 'token_bounded': return `${formatType(type.inner)}(max: ${type.max})`;
+        case 'enum': return type.values.join(' | ');
+        case 'struct': return `{ ${type.fields.map(f => `${f.name}: ${formatType(f.type)}`).join(', ')} }`;
+        case 'domain': return type.name;
+    }
+}
+function mkHover(value) {
+    return { contents: { kind: MarkupKind.Markdown, value } };
+}
+// formatExpr moved to src/format.ts in v5.0-R1
+export { formatExpr } from '../../format.js';

package/dist/lsp/features/index.d.ts

@@ -0,0 +1,9 @@
+export { toDiagnostics, extractUndefinedName } from './diagnostics.js';
+export { getHoverInfo, KEYWORD_DOCS, formatType } from './hover.js';
+export { getCompletions } from './completions.js';
+export { getDefinitionLocation } from './definition.js';
+export { getDocumentSymbols, makeSymbol } from './symbols.js';
+export { buildAutoImportActions, buildAutoImportEdit, computeRelativeImportPath } from './code-actions.js';
+export { isRenameable, collectRenameLocations, buildRenameEdits, GRAFT_KEYWORDS } from './rename.js';
+export { isReferable, findReferences } from './references.js';
+export { getWordAtPosition, isInComment, isInString } from './utils.js';

package/dist/lsp/features/index.js

@@ -0,0 +1,9 @@
+export { toDiagnostics, extractUndefinedName } from './diagnostics.js';
+export { getHoverInfo, KEYWORD_DOCS, formatType } from './hover.js';
+export { getCompletions } from './completions.js';
+export { getDefinitionLocation } from './definition.js';
+export { getDocumentSymbols, makeSymbol } from './symbols.js';
+export { buildAutoImportActions, buildAutoImportEdit, computeRelativeImportPath } from './code-actions.js';
+export { isRenameable, collectRenameLocations, buildRenameEdits, GRAFT_KEYWORDS } from './rename.js';
+export { isReferable, findReferences } from './references.js';
+export { getWordAtPosition, isInComment, isInString } from './utils.js';

package/dist/lsp/features/references.d.ts

@@ -0,0 +1,7 @@
+import type { Location } from 'vscode-languageserver/node';
+import type { ProgramIndex } from '../../program-index.js';
+export declare function isReferable(word: string, index: ProgramIndex): boolean;
+export declare function findReferences(name: string, currentDocText: string, currentDocUri: string, currentIndex: ProgramIndex, includeDeclaration: boolean, workspaceFiles: Map<string, {
+    text: string;
+    uri: string;
+}>): Location[];

package/dist/lsp/features/references.js

@@ -0,0 +1,53 @@
+import { collectRenameLocations } from './rename.js';
+export function isReferable(word, index) {
+    return (index.contextMap.has(word) ||
+        index.nodeMap.has(word) ||
+        index.memoryMap.has(word) ||
+        index.graphMap.has(word) ||
+        index.producesNodeMap.has(word));
+}
+/**
+ * Find the declaration name's 0-based position from ProgramIndex.
+ * Declaration locations point to the keyword token (e.g., "context" in "context Foo").
+ * The name starts at keyword column + keyword length + 1 (for the space).
+ * Uses location.length from SourceLocation rather than hardcoded keyword lengths.
+ */
+function findDeclNamePosition(name, index) {
+    const decl = index.contextMap.get(name) ?? index.nodeMap.get(name) ??
+        index.memoryMap.get(name) ?? index.graphMap.get(name);
+    if (decl && decl.location.length != null) {
+        return {
+            line: decl.location.line - 1,
+            character: decl.location.column - 1 + decl.location.length + 1,
+        };
+    }
+    const prodNode = index.producesNodeMap.get(name);
+    if (prodNode && prodNode.produces.location.length != null) {
+        return {
+            line: prodNode.produces.location.line - 1,
+            character: prodNode.produces.location.column - 1 + prodNode.produces.location.length + 1,
+        };
+    }
+    return null;
+}
+export function findReferences(name, currentDocText, currentDocUri, currentIndex, includeDeclaration, workspaceFiles) {
+    const locations = [];
+    // Declaration position for filtering when includeDeclaration is false
+    const declPos = includeDeclaration ? null : findDeclNamePosition(name, currentIndex);
+    // Current file
+    for (const range of collectRenameLocations(currentDocText, name)) {
+        if (declPos &&
+            range.start.line === declPos.line &&
+            range.start.character === declPos.character) {
+            continue; // Skip declaration
+        }
+        locations.push({ uri: currentDocUri, range });
+    }
+    // Cross-file references
+    for (const [, fileInfo] of workspaceFiles) {
+        for (const range of collectRenameLocations(fileInfo.text, name)) {
+            locations.push({ uri: fileInfo.uri, range });
+        }
+    }
+    return locations;
+}

package/dist/lsp/features/rename.d.ts

@@ -0,0 +1,17 @@
+import type { Range, TextEdit } from 'vscode-languageserver/node';
+import { ProgramIndex } from '../../program-index.js';
+export declare const GRAFT_KEYWORDS: Set<string>;
+/**
+ * Pure function that builds rename edits for a Graft identifier.
+ * Returns { changes } on success, { error } on validation/conflict failure, or null if not renameable.
+ */
+export declare function buildRenameEdits(oldName: string, newName: string, docText: string, docUri: string, currentFilePath: string, workspaceFiles: Map<string, {
+    text: string;
+    uri: string;
+}>): {
+    changes: Record<string, TextEdit[]>;
+} | {
+    error: string;
+} | null;
+export declare function isRenameable(word: string, index: ProgramIndex): boolean;
+export declare function collectRenameLocations(docText: string, name: string): Range[];

package/dist/lsp/features/rename.js

@@ -0,0 +1,198 @@
+import { Lexer } from '../../lexer/lexer.js';
+import { Parser } from '../../parser/parser.js';
+import { ProgramIndex } from '../../program-index.js';
+import { KEYWORDS } from '../../lexer/tokens.js';
+import { isInComment, isInString } from './utils.js';
+const TYPE_KEYWORDS = new Set([
+    'String', 'Int', 'Float', 'Bool', 'List', 'Map', 'Optional',
+    'TokenBounded', 'FilePath', 'FileDiff', 'TestFile', 'IssueRef',
+]);
+const CONTEXTUAL_KEYWORDS = new Set(['output']);
+// Derived from lexer KEYWORDS, excluding type keywords and contextual keywords
+export const GRAFT_KEYWORDS = new Set(Object.keys(KEYWORDS).filter(k => !TYPE_KEYWORDS.has(k) && !CONTEXTUAL_KEYWORDS.has(k)));
+/**
+ * Pure function that builds rename edits for a Graft identifier.
+ * Returns { changes } on success, { error } on validation/conflict failure, or null if not renameable.
+ */
+export function buildRenameEdits(oldName, newName, docText, docUri, currentFilePath, workspaceFiles) {
+    // Parse current file to check renameability
+    let index;
+    try {
+        const tokens = new Lexer(docText).tokenize();
+        const { program } = new Parser(tokens).parse();
+        index = new ProgramIndex(program);
+    }
+    catch {
+        return null;
+    }
+    // Check if the name is renameable (is a declared context/node/memory/graph)
+    if (!isRenameable(oldName, index))
+        return null;
+    // Validate newName is a legal Graft identifier
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(newName)) {
+        return { error: `'${newName}' is not a valid identifier` };
+    }
+    // Reject Graft keywords
+    if (GRAFT_KEYWORDS.has(newName)) {
+        return { error: `'${newName}' is a reserved keyword` };
+    }
+    // Check for conflicts in current file
+    if (oldName !== newName && (index.contextMap.has(newName) ||
+        index.nodeMap.has(newName) ||
+        index.memoryMap.has(newName) ||
+        index.graphMap.has(newName))) {
+        return { error: `'${newName}' already exists in the current file` };
+    }
+    // Check for field name collisions
+    const fieldCollision = findFieldCollision(newName, index);
+    if (fieldCollision) {
+        return { error: fieldCollision };
+    }
+    // Check for conflicts in importing files (parse-based)
+    for (const [filePath, fileInfo] of workspaceFiles) {
+        try {
+            const wsTokens = new Lexer(fileInfo.text).tokenize();
+            const { program: wsProgram } = new Parser(wsTokens).parse();
+            const wsIndex = new ProgramIndex(wsProgram);
+            if (wsIndex.contextMap.has(newName) || wsIndex.nodeMap.has(newName) ||
+                wsIndex.memoryMap.has(newName) || wsIndex.graphMap.has(newName)) {
+                return { error: `Name "${newName}" conflicts with declaration in ${filePath}` };
+            }
+        }
+        catch {
+            // Parse failure -- skip conflict check for this file
+        }
+    }
+    const changes = {};
+    // Collect locations in current file
+    const currentLocs = collectRenameLocations(docText, oldName);
+    if (currentLocs.length > 0) {
+        changes[docUri] = currentLocs.map(range => ({ range, newText: newName }));
+    }
+    // Collect locations in importing files
+    for (const [, fileInfo] of workspaceFiles) {
+        const locs = collectRenameLocations(fileInfo.text, oldName);
+        if (locs.length > 0) {
+            changes[fileInfo.uri] = locs.map(range => ({ range, newText: newName }));
+        }
+    }
+    return { changes };
+}
+export function isRenameable(word, index) {
+    return (index.contextMap.has(word) ||
+        index.nodeMap.has(word) ||
+        index.memoryMap.has(word) ||
+        index.graphMap.has(word));
+}
+export function collectRenameLocations(docText, name) {
+    // Normalize CRLF to LF
+    docText = docText.replace(/\r\n/g, '\n');
+    // Parse document to extract import path ranges for AST-based filtering
+    const importPathRanges = getImportPathRanges(docText);
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`\\b${escaped}\\b`, 'g');
+    const ranges = [];
+    const lines = docText.split('\n');
+    const lineOffsets = [];
+    let offset = 0;
+    for (const line of lines) {
+        lineOffsets.push(offset);
+        offset += line.length + 1;
+    }
+    let match;
+    while ((match = regex.exec(docText)) !== null) {
+        const matchOffset = match.index;
+        let lo = 0;
+        let hi = lineOffsets.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineOffsets[mid] <= matchOffset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        const line = lo;
+        const character = matchOffset - lineOffsets[line];
+        // Skip matches inside comments
+        if (isInComment(lines, line, character + 1))
+            continue;
+        // Skip matches inside strings
+        const lineText = lines[line];
+        if (isInString(lineText, character))
+            continue;
+        // Skip matches inside import path strings (AST-based)
+        if (isInImportPath(matchOffset, match[0].length, importPathRanges))
+            continue;
+        ranges.push({
+            start: { line, character },
+            end: { line, character: character + name.length },
+        });
+    }
+    return ranges;
+}
+/**
+ * Parse the document and return offset ranges for all import path strings.
+ * Each range is [start, end) covering the path string content (inside quotes).
+ */
+function getImportPathRanges(docText) {
+    const ranges = [];
+    try {
+        const tokens = new Lexer(docText).tokenize();
+        const { program } = new Parser(tokens).parse();
+        for (const imp of program.imports) {
+            // Find the import path string in the source text after the import location
+            // The path is a string literal like "path/to/file" in `from "path/to/file"`
+            const searchStart = imp.location.offset;
+            const fromIdx = docText.indexOf('from', searchStart);
+            if (fromIdx === -1)
+                continue;
+            const quoteStart = docText.indexOf('"', fromIdx);
+            if (quoteStart === -1)
+                continue;
+            const quoteEnd = docText.indexOf('"', quoteStart + 1);
+            if (quoteEnd === -1)
+                continue;
+            // Range covers content inside quotes (exclusive of quotes themselves)
+            ranges.push({ start: quoteStart + 1, end: quoteEnd });
+        }
+    }
+    catch {
+        // If parsing fails, return empty ranges (no import filtering)
+    }
+    return ranges;
+}
+function isInImportPath(matchOffset, matchLength, importPathRanges) {
+    for (const range of importPathRanges) {
+        if (matchOffset >= range.start && matchOffset + matchLength <= range.end) {
+            return true;
+        }
+    }
+    return false;
+}
+function findFieldCollision(newName, index) {
+    // Check context fields
+    for (const [ctxName, ctx] of index.contextMap) {
+        for (const field of ctx.fields) {
+            if (field.name === newName) {
+                return `'${newName}' collides with field '${newName}' in context '${ctxName}'`;
+            }
+        }
+    }
+    // Check memory fields
+    for (const [memName, mem] of index.memoryMap) {
+        for (const field of mem.fields) {
+            if (field.name === newName) {
+                return `'${newName}' collides with field '${newName}' in memory '${memName}'`;
+            }
+        }
+    }
+    // Check produces fields (node output fields)
+    for (const [nodeName, node] of index.nodeMap) {
+        for (const field of node.produces.fields) {
+            if (field.name === newName) {
+                return `'${newName}' collides with field '${newName}' in node '${nodeName}'`;
+            }
+        }
+    }
+    return null;
+}

package/dist/lsp/features/symbols.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentSymbol } from 'vscode-languageserver/node';
+import { SymbolKind } from 'vscode-languageserver/node';
+import type { SourceLocation } from '../../errors/diagnostics.js';
+import type { Program } from '../../parser/ast.js';
+import type { ProgramIndex } from '../../program-index.js';
+export declare function getDocumentSymbols(program: Program, index: ProgramIndex): DocumentSymbol[];
+export declare function makeSymbol(name: string, kind: SymbolKind, loc: SourceLocation): DocumentSymbol;

package/dist/lsp/features/symbols.js

@@ -0,0 +1,74 @@
+import { SymbolKind } from 'vscode-languageserver/node';
+export function getDocumentSymbols(program, index) {
+    const symbols = [];
+    for (const ctx of program.contexts) {
+        const sym = makeSymbol(ctx.name, SymbolKind.Class, ctx.location);
+        sym.children = makeFieldChildren(ctx.fields);
+        symbols.push(sym);
+    }
+    for (const node of program.nodes) {
+        const sym = makeSymbol(node.name, SymbolKind.Function, node.location);
+        sym.children = makeFieldChildren(node.produces.fields);
+        symbols.push(sym);
+    }
+    for (const mem of program.memories) {
+        const sym = makeSymbol(mem.name, SymbolKind.Variable, mem.location);
+        sym.children = makeFieldChildren(mem.fields);
+        symbols.push(sym);
+    }
+    for (const graph of program.graphs) {
+        const sym = makeSymbol(graph.name, SymbolKind.Module, graph.location);
+        sym.children = makeFlowNodeChildren(graph.flow, graph.location);
+        symbols.push(sym);
+    }
+    for (const edge of program.edges) {
+        const targetName = edge.target.kind === 'direct' ? edge.target.node : 'conditional';
+        symbols.push(makeSymbol(`${edge.source} -> ${targetName}`, SymbolKind.Event, edge.location));
+    }
+    return symbols;
+}
+function makeFieldChildren(fields) {
+    return fields.map(f => makeSymbol(f.name, SymbolKind.Field, f.location));
+}
+function makeFlowNodeChildren(flow, parentLoc) {
+    const children = [];
+    for (const node of flow) {
+        if (node.kind === 'node') {
+            children.push(makeSymbol(node.name, SymbolKind.Function, node.location ?? parentLoc));
+        }
+        else if (node.kind === 'parallel') {
+            const label = `parallel(${node.branches.join(', ')})`;
+            children.push(makeSymbol(label, SymbolKind.Function, node.location ?? parentLoc));
+        }
+        else if (node.kind === 'foreach') {
+            const label = `foreach(${node.source}.${node.field})`;
+            const sym = makeSymbol(label, SymbolKind.Function, node.location ?? parentLoc);
+            sym.children = makeFlowNodeChildren(node.body, node.location ?? parentLoc);
+            children.push(sym);
+        }
+        else if (node.kind === 'let') {
+            children.push(makeSymbol(`let ${node.name}`, SymbolKind.Variable, node.location ?? parentLoc));
+        }
+        else if (node.kind === 'graph_call') {
+            const label = `${node.name}(${node.args.map(a => a.name).join(', ')})`;
+            children.push(makeSymbol(label, SymbolKind.Function, node.location ?? parentLoc));
+        }
+    }
+    return children;
+}
+export function makeSymbol(name, kind, loc) {
+    const line = Math.max(0, loc.line - 1);
+    const character = Math.max(0, loc.column - 1);
+    // range spans from keyword start to past the name (keyword + space + name)
+    const rangeEnd = loc.length != null ? loc.length + 1 + name.length : name.length;
+    const range = {
+        start: { line, character },
+        end: { line, character: character + rangeEnd },
+    };
+    const nameStart = loc.length != null ? character + loc.length + 1 : character;
+    const selectionRange = {
+        start: { line, character: nameStart },
+        end: { line, character: nameStart + name.length },
+    };
+    return { name, kind, range, selectionRange };
+}

package/dist/lsp/features/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function isInComment(lines: string[], line: number, character: number): boolean;
+export declare function isInString(lineText: string, character: number): boolean;
+export declare function getWordAtPosition(text: string, line: number, character: number): string | null;

package/dist/lsp/features/utils.js

@@ -0,0 +1,65 @@
+export function isInComment(lines, line, character) {
+    let inBlock = false;
+    for (let i = 0; i <= line; i++) {
+        const l = (lines[i] ?? '').replace(/\r$/, '');
+        const endCol = i === line ? character : l.length;
+        let j = 0;
+        while (j < endCol) {
+            if (!inBlock) {
+                if (l[j] === '/' && j + 1 < l.length && l[j + 1] === '/') {
+                    if (i === line)
+                        return true;
+                    break;
+                }
+                if (l[j] === '/' && j + 1 < l.length && l[j + 1] === '*') {
+                    inBlock = true;
+                    j += 2;
+                    continue;
+                }
+                if (l[j] === '"') {
+                    j++;
+                    while (j < endCol && l[j] !== '"')
+                        j++;
+                    if (j < endCol)
+                        j++;
+                    continue;
+                }
+            }
+            else {
+                if (l[j] === '*' && j + 1 < l.length && l[j + 1] === '/') {
+                    inBlock = false;
+                    j += 2;
+                    continue;
+                }
+            }
+            j++;
+        }
+    }
+    return inBlock;
+}
+export function isInString(lineText, character) {
+    let inStr = false;
+    for (let i = 0; i < character && i < lineText.length; i++) {
+        if (lineText[i] === '"')
+            inStr = !inStr;
+    }
+    return inStr;
+}
+export function getWordAtPosition(text, line, character) {
+    const lines = text.split('\n');
+    if (line < 0 || line >= lines.length)
+        return null;
+    const lineText = lines[line];
+    if (character < 0 || character > lineText.length)
+        return null;
+    const pattern = /[A-Za-z_][A-Za-z0-9_]*/g;
+    let match;
+    while ((match = pattern.exec(lineText)) !== null) {
+        const start = match.index;
+        const end = start + match[0].length;
+        if (character >= start && character < end) {
+            return match[0];
+        }
+    }
+    return null;
+}

package/dist/lsp/features.d.ts

@@ -0,0 +1,20 @@
+import type { Diagnostic, Hover, Location, CompletionItem, DocumentSymbol } from 'vscode-languageserver/node';
+import type { GraftError } from '../errors/diagnostics.js';
+import type { Program, TypeExpr } from '../parser/ast.js';
+import type { ProgramIndex } from '../program-index.js';
+export declare function toDiagnostics(errors: GraftError[], warnings: GraftError[]): Diagnostic[];
+export declare function getDocumentSymbols(program: Program, index: ProgramIndex): DocumentSymbol[];
+export declare function getWordAtPosition(text: string, line: number, character: number): string | null;
+export declare function getHoverInfo(word: string, index: ProgramIndex): Hover | null;
+export declare function getDefinitionLocation(word: string, index: ProgramIndex, currentUri: string): Location | null;
+export declare function formatType(type: TypeExpr): string;
+export declare function getCompletions(text: string, line: number, character: number, cache: {
+    program: Program;
+    index: ProgramIndex;
+} | null, resolveImportNames?: (importPath: string) => string[]): CompletionItem[];
+export declare function extractUndefinedName(message: string, docText: string, line: number, character: number): string | null;
+export declare function buildAutoImportEdit(name: string, fromPath: string, docText: string): {
+    insertLine: number;
+    newText: string;
+};
+export declare function computeRelativeImportPath(fromFile: string, toFile: string): string;