@jsleekr/graft 5.7.0

package/dist/lexer/tokens.d.ts

@@ -0,0 +1,96 @@
+import { SourceLocation } from '../errors/diagnostics.js';
+export declare enum TokenType {
+    Node = "Node",
+    Edge = "Edge",
+    Graph = "Graph",
+    Context = "Context",
+    Reads = "Reads",
+    Produces = "Produces",
+    Tools = "Tools",
+    Budget = "Budget",
+    Model = "Model",
+    Select = "Select",
+    Filter = "Filter",
+    Drop = "Drop",
+    Compact = "Compact",
+    Truncate = "Truncate",
+    When = "When",
+    Else = "Else",
+    Done = "Done",
+    OnFailure = "OnFailure",
+    Retry = "Retry",
+    Fallback = "Fallback",
+    Skip = "Skip",
+    Abort = "Abort",
+    Input = "Input",
+    Output = "Output",
+    MaxTokens = "MaxTokens",
+    Enum = "Enum",
+    True = "True",
+    False = "False",
+    Parallel = "Parallel",
+    Foreach = "Foreach",
+    As = "As",
+    MaxIterations = "MaxIterations",
+    Import = "Import",
+    From = "From",
+    Memory = "Memory",
+    Writes = "Writes",
+    Storage = "Storage",
+    Let = "Let",
+    Then = "Then",
+    If = "If",
+    String = "String",
+    Int = "Int",
+    Float = "Float",
+    Bool = "Bool",
+    List = "List",
+    Map = "Map",
+    Optional = "Optional",
+    TokenBounded = "TokenBounded",
+    FilePath = "FilePath",
+    FileDiff = "FileDiff",
+    TestFile = "TestFile",
+    IssueRef = "IssueRef",
+    IntegerLiteral = "IntegerLiteral",
+    KIntegerLiteral = "KIntegerLiteral",
+    FloatLiteral = "FloatLiteral",
+    StringLiteral = "StringLiteral",
+    TemplateString = "TemplateString",
+    Identifier = "Identifier",
+    LBrace = "LBrace",
+    RBrace = "RBrace",
+    LParen = "LParen",
+    RParen = "RParen",
+    LBracket = "LBracket",
+    RBracket = "RBracket",
+    Colon = "Colon",
+    Comma = "Comma",
+    Dot = "Dot",
+    Arrow = "Arrow",
+    Pipe = "Pipe",
+    Slash = "Slash",
+    Star = "Star",
+    Percent = "Percent",
+    Plus = "Plus",
+    Minus = "Minus",
+    Bang = "Bang",
+    Equals = "Equals",
+    DotDot = "DotDot",
+    GreaterEqual = "GreaterEqual",
+    Greater = "Greater",
+    LessEqual = "LessEqual",
+    Less = "Less",
+    EqualEqual = "EqualEqual",
+    BangEqual = "BangEqual",
+    AmpAmp = "AmpAmp",
+    PipePipe = "PipePipe",
+    QuestionQuestion = "QuestionQuestion",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    location: SourceLocation;
+}
+export declare const KEYWORDS: Record<string, TokenType>;

package/dist/lexer/tokens.js

@@ -0,0 +1,150 @@
+export var TokenType;
+(function (TokenType) {
+    // Keywords
+    TokenType["Node"] = "Node";
+    TokenType["Edge"] = "Edge";
+    TokenType["Graph"] = "Graph";
+    TokenType["Context"] = "Context";
+    TokenType["Reads"] = "Reads";
+    TokenType["Produces"] = "Produces";
+    TokenType["Tools"] = "Tools";
+    TokenType["Budget"] = "Budget";
+    TokenType["Model"] = "Model";
+    TokenType["Select"] = "Select";
+    TokenType["Filter"] = "Filter";
+    TokenType["Drop"] = "Drop";
+    TokenType["Compact"] = "Compact";
+    TokenType["Truncate"] = "Truncate";
+    TokenType["When"] = "When";
+    TokenType["Else"] = "Else";
+    TokenType["Done"] = "Done";
+    TokenType["OnFailure"] = "OnFailure";
+    TokenType["Retry"] = "Retry";
+    TokenType["Fallback"] = "Fallback";
+    TokenType["Skip"] = "Skip";
+    TokenType["Abort"] = "Abort";
+    TokenType["Input"] = "Input";
+    TokenType["Output"] = "Output";
+    TokenType["MaxTokens"] = "MaxTokens";
+    TokenType["Enum"] = "Enum";
+    TokenType["True"] = "True";
+    TokenType["False"] = "False";
+    TokenType["Parallel"] = "Parallel";
+    TokenType["Foreach"] = "Foreach";
+    TokenType["As"] = "As";
+    TokenType["MaxIterations"] = "MaxIterations";
+    TokenType["Import"] = "Import";
+    TokenType["From"] = "From";
+    TokenType["Memory"] = "Memory";
+    TokenType["Writes"] = "Writes";
+    TokenType["Storage"] = "Storage";
+    TokenType["Let"] = "Let";
+    TokenType["Then"] = "Then";
+    TokenType["If"] = "If";
+    // Type keywords
+    TokenType["String"] = "String";
+    TokenType["Int"] = "Int";
+    TokenType["Float"] = "Float";
+    TokenType["Bool"] = "Bool";
+    TokenType["List"] = "List";
+    TokenType["Map"] = "Map";
+    TokenType["Optional"] = "Optional";
+    TokenType["TokenBounded"] = "TokenBounded";
+    TokenType["FilePath"] = "FilePath";
+    TokenType["FileDiff"] = "FileDiff";
+    TokenType["TestFile"] = "TestFile";
+    TokenType["IssueRef"] = "IssueRef";
+    // Literals
+    TokenType["IntegerLiteral"] = "IntegerLiteral";
+    TokenType["KIntegerLiteral"] = "KIntegerLiteral";
+    TokenType["FloatLiteral"] = "FloatLiteral";
+    TokenType["StringLiteral"] = "StringLiteral";
+    TokenType["TemplateString"] = "TemplateString";
+    // Identifiers
+    TokenType["Identifier"] = "Identifier";
+    // Symbols
+    TokenType["LBrace"] = "LBrace";
+    TokenType["RBrace"] = "RBrace";
+    TokenType["LParen"] = "LParen";
+    TokenType["RParen"] = "RParen";
+    TokenType["LBracket"] = "LBracket";
+    TokenType["RBracket"] = "RBracket";
+    TokenType["Colon"] = "Colon";
+    TokenType["Comma"] = "Comma";
+    TokenType["Dot"] = "Dot";
+    TokenType["Arrow"] = "Arrow";
+    TokenType["Pipe"] = "Pipe";
+    TokenType["Slash"] = "Slash";
+    TokenType["Star"] = "Star";
+    TokenType["Percent"] = "Percent";
+    TokenType["Plus"] = "Plus";
+    TokenType["Minus"] = "Minus";
+    TokenType["Bang"] = "Bang";
+    TokenType["Equals"] = "Equals";
+    TokenType["DotDot"] = "DotDot";
+    TokenType["GreaterEqual"] = "GreaterEqual";
+    TokenType["Greater"] = "Greater";
+    TokenType["LessEqual"] = "LessEqual";
+    TokenType["Less"] = "Less";
+    TokenType["EqualEqual"] = "EqualEqual";
+    TokenType["BangEqual"] = "BangEqual";
+    TokenType["AmpAmp"] = "AmpAmp";
+    TokenType["PipePipe"] = "PipePipe";
+    TokenType["QuestionQuestion"] = "QuestionQuestion";
+    // Special
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+export const KEYWORDS = {
+    node: TokenType.Node,
+    edge: TokenType.Edge,
+    graph: TokenType.Graph,
+    context: TokenType.Context,
+    reads: TokenType.Reads,
+    produces: TokenType.Produces,
+    tools: TokenType.Tools,
+    budget: TokenType.Budget,
+    model: TokenType.Model,
+    select: TokenType.Select,
+    filter: TokenType.Filter,
+    drop: TokenType.Drop,
+    compact: TokenType.Compact,
+    truncate: TokenType.Truncate,
+    when: TokenType.When,
+    else: TokenType.Else,
+    done: TokenType.Done,
+    on_failure: TokenType.OnFailure,
+    retry: TokenType.Retry,
+    fallback: TokenType.Fallback,
+    skip: TokenType.Skip,
+    abort: TokenType.Abort,
+    input: TokenType.Input,
+    output: TokenType.Output,
+    max_tokens: TokenType.MaxTokens,
+    enum: TokenType.Enum,
+    true: TokenType.True,
+    false: TokenType.False,
+    parallel: TokenType.Parallel,
+    foreach: TokenType.Foreach,
+    as: TokenType.As,
+    max_iterations: TokenType.MaxIterations,
+    import: TokenType.Import,
+    from: TokenType.From,
+    memory: TokenType.Memory,
+    writes: TokenType.Writes,
+    storage: TokenType.Storage,
+    let: TokenType.Let,
+    then: TokenType.Then,
+    if: TokenType.If,
+    String: TokenType.String,
+    Int: TokenType.Int,
+    Float: TokenType.Float,
+    Bool: TokenType.Bool,
+    List: TokenType.List,
+    Map: TokenType.Map,
+    Optional: TokenType.Optional,
+    TokenBounded: TokenType.TokenBounded,
+    FilePath: TokenType.FilePath,
+    FileDiff: TokenType.FileDiff,
+    TestFile: TokenType.TestFile,
+    IssueRef: TokenType.IssueRef,
+};

package/dist/lsp/features/code-actions.d.ts

@@ -0,0 +1,7 @@
+import type { CodeAction, Diagnostic } from 'vscode-languageserver/node';
+export declare function buildAutoImportActions(docText: string, docUri: string, currentFilePath: string, diagnostics: Diagnostic[], workspaceExports: Map<string, string[]>): CodeAction[];
+export declare function buildAutoImportEdit(name: string, fromPath: string, docText: string): {
+    insertLine: number;
+    newText: string;
+};
+export declare function computeRelativeImportPath(fromFile: string, toFile: string): string;

package/dist/lsp/features/code-actions.js

@@ -0,0 +1,58 @@
+import * as path from 'node:path';
+import { CodeActionKind } from 'vscode-languageserver/node';
+import { extractUndefinedName } from './diagnostics.js';
+export function buildAutoImportActions(docText, docUri, currentFilePath, diagnostics, workspaceExports) {
+    const actions = [];
+    // Collect already-imported names
+    const importedNames = new Set();
+    for (const line of docText.split('\n')) {
+        const m = line.match(/^\s*import\s+\{([^}]+)\}/);
+        if (m) {
+            for (const n of m[1].split(','))
+                importedNames.add(n.trim());
+        }
+    }
+    for (const diag of diagnostics) {
+        if (diag.code !== 'SCOPE_UNDEFINED_REF')
+            continue;
+        const name = extractUndefinedName(diag.message, docText, diag.range.start.line, diag.range.start.character);
+        if (!name || importedNames.has(name))
+            continue;
+        for (const [filePath, exports] of workspaceExports) {
+            if (filePath === currentFilePath || !exports.includes(name))
+                continue;
+            const relPath = computeRelativeImportPath(currentFilePath, filePath);
+            const edit = buildAutoImportEdit(name, relPath, docText);
+            actions.push({
+                title: `Import '${name}' from "${relPath}"`,
+                kind: CodeActionKind.QuickFix,
+                edit: {
+                    changes: {
+                        [docUri]: [{
+                                range: { start: { line: edit.insertLine, character: 0 }, end: { line: edit.insertLine, character: 0 } },
+                                newText: edit.newText,
+                            }],
+                    },
+                },
+            });
+        }
+    }
+    return actions;
+}
+export function buildAutoImportEdit(name, fromPath, docText) {
+    const lines = docText.split('\n');
+    let insertLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^\s*import\s+\{/.test(lines[i])) {
+            insertLine = i + 1;
+        }
+    }
+    return { insertLine, newText: `import { ${name} } from "${fromPath}"\n` };
+}
+export function computeRelativeImportPath(fromFile, toFile) {
+    let rel = path.relative(path.dirname(fromFile), toFile);
+    rel = rel.replace(/\\/g, '/'); // Windows path normalization
+    if (!rel.startsWith('.'))
+        rel = './' + rel;
+    return rel;
+}

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

@@ -0,0 +1,7 @@
+import type { CompletionItem } from 'vscode-languageserver/node';
+import { type Program } from '../../parser/ast.js';
+import type { ProgramIndex } from '../../program-index.js';
+export declare function getCompletions(text: string, line: number, character: number, cache: {
+    program: Program;
+    index: ProgramIndex;
+} | null, resolveImportNames?: (importPath: string) => string[]): CompletionItem[];

package/dist/lsp/features/completions.js

@@ -0,0 +1,271 @@
+import { CompletionItemKind, InsertTextFormat } from 'vscode-languageserver/node';
+import { BUILTIN_FUNCTIONS } from '../../parser/ast.js';
+import { MODEL_MAP } from '../../constants.js';
+import { formatType } from './hover.js';
+import { isInComment, isInString } from './utils.js';
+export function getCompletions(text, line, character, cache, resolveImportNames) {
+    const lines = text.split('\n');
+    if (line < 0 || line >= lines.length)
+        return [];
+    const lineText = lines[line].replace(/\r$/, '');
+    const before = lineText.slice(0, character);
+    // Suppress completions inside comments
+    if (isInComment(lines, line, character))
+        return [];
+    // Suppress completions inside string literals
+    if (isInString(lineText, character))
+        return [];
+    // After `storage:` -> storage types
+    if (/storage\s*:\s*\w*$/.test(before)) {
+        return [{ label: 'file', kind: CompletionItemKind.EnumMember, detail: 'File-based storage' }];
+    }
+    // After `model:` -> model aliases
+    if (/model\s*:\s*\w*$/.test(before)) {
+        return Object.entries(MODEL_MAP).map(([alias, full]) => ({
+            label: alias,
+            kind: CompletionItemKind.EnumMember,
+            detail: full,
+        }));
+    }
+    // After `on_failure:` -> strategy keywords
+    if (/on_failure\s*:\s*\w*$/.test(before)) {
+        return [
+            { label: 'retry', kind: CompletionItemKind.Keyword,
+                insertText: 'retry(${1:3})', insertTextFormat: InsertTextFormat.Snippet },
+            { label: 'fallback', kind: CompletionItemKind.Keyword,
+                insertText: 'fallback(${1:NodeName})', insertTextFormat: InsertTextFormat.Snippet },
+            { label: 'skip', kind: CompletionItemKind.Keyword },
+            { label: 'abort', kind: CompletionItemKind.Keyword },
+            { label: 'retry_then_fallback', kind: CompletionItemKind.Keyword,
+                insertText: 'retry(${1:3}, fallback(${2:NodeName}))',
+                insertTextFormat: InsertTextFormat.Snippet,
+                detail: 'Retry N times, then fallback to node' },
+        ];
+    }
+    // Inside `fallback(` -> node names
+    if (/fallback\s*\(\s*\w*$/.test(before)) {
+        if (!cache)
+            return [];
+        return [...cache.index.nodeMap.keys()].map(name => ({
+            label: name,
+            kind: CompletionItemKind.Class,
+            detail: 'node',
+        }));
+    }
+    // Inside `import { }` -> names from resolver
+    if (isInsideImportBraces(lines, line, character)) {
+        if (!resolveImportNames)
+            return [];
+        const importPath = extractImportPath(lines, line) ?? '';
+        const names = resolveImportNames(importPath);
+        return names.map(name => ({
+            label: name,
+            kind: CompletionItemKind.Class,
+            detail: 'importable',
+        }));
+    }
+    // After `Name.` -> field completions (also handles multi-field brace `Name.{f1, `)
+    const dotMatch = before.match(/([A-Za-z_]\w*)\.\s*(?:\{[^}]*)?\s*\w*$/);
+    if (dotMatch) {
+        return getFieldCompletions(dotMatch[1], cache?.index ?? null);
+    }
+    // Inside `reads: [` -> context + memory + produces names
+    if (isInsideBracketAfter(lines, line, character, 'reads')) {
+        if (!cache)
+            return [];
+        const items = [];
+        for (const name of cache.index.contextMap.keys()) {
+            items.push({ label: name, kind: CompletionItemKind.Class, detail: 'context' });
+        }
+        for (const name of cache.index.producesNodeMap.keys()) {
+            items.push({ label: name, kind: CompletionItemKind.Struct, detail: 'produces' });
+        }
+        for (const name of cache.index.memoryMap.keys()) {
+            items.push({ label: name, kind: CompletionItemKind.Variable, detail: 'memory' });
+        }
+        return items;
+    }
+    // Inside `writes: [` -> memory names only
+    if (isInsideBracketAfter(lines, line, character, 'writes')) {
+        if (!cache)
+            return [];
+        return [...cache.index.memoryMap.keys()].map(name => ({
+            label: name,
+            kind: CompletionItemKind.Variable,
+            detail: 'memory',
+        }));
+    }
+    // Inside graph flow -> node names + done
+    if (isInsideBlock(lines, line, 'graph')) {
+        const items = [
+            { label: 'done', kind: CompletionItemKind.Keyword, detail: 'Terminal node' },
+            { label: 'let', kind: CompletionItemKind.Keyword, detail: 'Variable binding' },
+        ];
+        if (cache) {
+            for (const name of cache.index.nodeMap.keys()) {
+                items.push({ label: name, kind: CompletionItemKind.Class, detail: 'node' });
+            }
+            for (const name of cache.index.graphMap.keys()) {
+                items.push({ label: name, kind: CompletionItemKind.Module, detail: 'graph call' });
+            }
+        }
+        // Built-in expression functions
+        for (const [name, info] of Object.entries(BUILTIN_FUNCTIONS)) {
+            items.push({ label: name, kind: CompletionItemKind.Function, detail: `builtin (${info.arity} arg${info.arity !== 1 ? 's' : ''})` });
+        }
+        // Expression keywords
+        items.push({ label: 'if', kind: CompletionItemKind.Keyword, detail: 'Conditional expression' });
+        items.push({ label: 'true', kind: CompletionItemKind.Keyword, detail: 'Boolean literal' });
+        items.push({ label: 'false', kind: CompletionItemKind.Keyword, detail: 'Boolean literal' });
+        // Variable names from let bindings
+        if (cache) {
+            for (const [name, binding] of cache.index.letBindingMap) {
+                items.push({ label: name, kind: CompletionItemKind.Variable, detail: `variable (graph ${binding.graphName})` });
+            }
+        }
+        return items;
+    }
+    // Top-level -> keyword completions + snippets
+    if (/^\s*\w*$/.test(before)) {
+        return topLevelCompletions();
+    }
+    return [];
+}
+function getFieldCompletions(name, index) {
+    if (!index)
+        return [];
+    const ctx = index.contextMap.get(name);
+    if (ctx) {
+        return ctx.fields.map(f => ({
+            label: f.name,
+            kind: CompletionItemKind.Field,
+            detail: formatType(f.type),
+        }));
+    }
+    const pf = index.producesFieldsMap.get(name);
+    if (pf) {
+        return [...pf.entries()].map(([fieldName, type]) => ({
+            label: fieldName,
+            kind: CompletionItemKind.Field,
+            detail: formatType(type),
+        }));
+    }
+    const mf = index.memoryFieldsMap.get(name);
+    if (mf) {
+        return [...mf.entries()].map(([fieldName, type]) => ({
+            label: fieldName,
+            kind: CompletionItemKind.Field,
+            detail: formatType(type),
+        }));
+    }
+    return [];
+}
+function isInsideBracketAfter(lines, currentLine, character, keyword) {
+    let depth = 0;
+    for (let i = currentLine; i >= 0; i--) {
+        const l = (lines[i] ?? '').replace(/\r$/, '');
+        const end = i === currentLine ? character : l.length;
+        for (let j = end - 1; j >= 0; j--) {
+            if (l[j] === ']')
+                depth++;
+            if (l[j] === '[') {
+                if (depth > 0) {
+                    depth--;
+                }
+                else {
+                    const prefix = l.slice(0, j).trimEnd();
+                    return prefix.endsWith(keyword + ':') || prefix.endsWith(keyword);
+                }
+            }
+        }
+    }
+    return false;
+}
+function isInsideImportBraces(lines, currentLine, character) {
+    let depth = 0;
+    for (let i = currentLine; i >= 0; i--) {
+        const l = (lines[i] ?? '').replace(/\r$/, '');
+        const end = i === currentLine ? character : l.length;
+        for (let j = end - 1; j >= 0; j--) {
+            if (l[j] === '}')
+                depth++;
+            if (l[j] === '{') {
+                if (depth > 0) {
+                    depth--;
+                }
+                else {
+                    const prefix = l.slice(0, j).trimEnd();
+                    return /\bimport\s*$/.test(prefix);
+                }
+            }
+        }
+    }
+    return false;
+}
+function extractImportPath(lines, startLine) {
+    for (let i = startLine; i < Math.min(startLine + 3, lines.length); i++) {
+        const match = lines[i].match(/from\s+"([^"]+)"/);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+function isInsideBlock(lines, currentLine, keyword) {
+    let depth = 0;
+    for (let i = currentLine; i >= 0; i--) {
+        const l = (lines[i] ?? '').replace(/\r$/, '');
+        for (let j = l.length - 1; j >= 0; j--) {
+            if (l[j] === '}')
+                depth++;
+            if (l[j] === '{') {
+                if (depth > 0) {
+                    depth--;
+                }
+                else {
+                    return new RegExp(`^\\s*${keyword}\\s`).test(l);
+                }
+            }
+        }
+    }
+    return false;
+}
+function topLevelCompletions() {
+    return [
+        {
+            label: 'context',
+            kind: CompletionItemKind.Keyword,
+            detail: 'Declare a context schema',
+            insertText: 'context ${1:Name}(max_tokens: ${2:1k}) {\n  ${3:field}: ${4:String}\n}',
+            insertTextFormat: InsertTextFormat.Snippet,
+        },
+        {
+            label: 'node',
+            kind: CompletionItemKind.Keyword,
+            detail: 'Declare a processing node',
+            insertText: 'node ${1:Name}(model: ${2:sonnet}, budget: ${3:5k}/${4:2k}) {\n  reads: [${5}]\n  produces ${6:Output} {\n    ${7:field}: ${8:String}\n  }\n}',
+            insertTextFormat: InsertTextFormat.Snippet,
+        },
+        {
+            label: 'memory',
+            kind: CompletionItemKind.Keyword,
+            detail: 'Declare persistent memory',
+            insertText: 'memory ${1:Name}(max_tokens: ${2:2k}, storage: file) {\n  ${3:field}: ${4:String}\n}',
+            insertTextFormat: InsertTextFormat.Snippet,
+        },
+        {
+            label: 'graph',
+            kind: CompletionItemKind.Keyword,
+            detail: 'Declare execution graph',
+            insertText: 'graph ${1:Name}(input: ${2:Input}, output: ${3:Output}, budget: ${4:10k}) {\n  ${5:Start} -> done\n}',
+            insertTextFormat: InsertTextFormat.Snippet,
+        },
+        { label: 'edge', kind: CompletionItemKind.Keyword, detail: 'Declare edge transform' },
+        {
+            label: 'import',
+            kind: CompletionItemKind.Keyword,
+            detail: 'Import from another file',
+            insertText: 'import { ${1:Name} } from "${2:./lib.gft}"',
+            insertTextFormat: InsertTextFormat.Snippet,
+        },
+    ];
+}

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

@@ -0,0 +1,3 @@
+import type { Location } from 'vscode-languageserver/node';
+import type { ProgramIndex } from '../../program-index.js';
+export declare function getDefinitionLocation(word: string, index: ProgramIndex, currentUri: string): Location | null;

package/dist/lsp/features/definition.js

@@ -0,0 +1,32 @@
+import { pathToFileURL } from 'node:url';
+export function getDefinitionLocation(word, index, currentUri) {
+    const ctx = index.contextMap.get(word);
+    if (ctx)
+        return declLocation(ctx.location, ctx.sourceFile, word.length, currentUri);
+    const node = index.nodeMap.get(word);
+    if (node)
+        return declLocation(node.location, node.sourceFile, word.length, currentUri);
+    const producerNode = index.producesNodeMap.get(word);
+    if (producerNode) {
+        return declLocation(producerNode.produces.location, producerNode.sourceFile, word.length, currentUri);
+    }
+    const mem = index.memoryMap.get(word);
+    if (mem)
+        return declLocation(mem.location, undefined, word.length, currentUri);
+    const letBinding = index.letBindingMap.get(word);
+    if (letBinding?.location)
+        return declLocation(letBinding.location, undefined, word.length, currentUri);
+    return null;
+}
+function declLocation(loc, sourceFile, nameLength, currentUri) {
+    const uri = sourceFile ? pathToFileURL(sourceFile).toString() : currentUri;
+    const line = Math.max(0, loc.line - 1);
+    const character = Math.max(0, loc.column - 1);
+    return {
+        uri,
+        range: {
+            start: { line, character },
+            end: { line, character: character + nameLength },
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Diagnostic } from 'vscode-languageserver/node';
+import type { GraftError } from '../../errors/diagnostics.js';
+export declare function toDiagnostics(errors: GraftError[], warnings: GraftError[]): Diagnostic[];
+export declare function extractUndefinedName(message: string, docText: string, line: number, character: number): string | null;

package/dist/lsp/features/diagnostics.js

@@ -0,0 +1,33 @@
+import { DiagnosticSeverity } from 'vscode-languageserver/node';
+import { getWordAtPosition } from './utils.js';
+export function toDiagnostics(errors, warnings) {
+    const result = [];
+    for (const e of errors) {
+        result.push(makeDiagnostic(e, DiagnosticSeverity.Error));
+    }
+    for (const w of warnings) {
+        result.push(makeDiagnostic(w, DiagnosticSeverity.Warning));
+    }
+    return result;
+}
+function makeDiagnostic(e, severity) {
+    const line = Math.max(0, e.location.line - 1);
+    const character = Math.max(0, e.location.column - 1);
+    const endCharacter = character + (e.location.length ?? 1);
+    return {
+        range: {
+            start: { line, character },
+            end: { line, character: endCharacter },
+        },
+        severity,
+        message: e.message,
+        source: 'graft',
+        ...(e.code ? { code: e.code } : {}),
+    };
+}
+export function extractUndefinedName(message, docText, line, character) {
+    const msgMatch = message.match(/'([^']+)'/);
+    if (msgMatch)
+        return msgMatch[1];
+    return getWordAtPosition(docText, line, character);
+}

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

@@ -0,0 +1,7 @@
+import type { Hover } from 'vscode-languageserver/node';
+import { type TypeExpr } from '../../parser/ast.js';
+import type { ProgramIndex } from '../../program-index.js';
+export declare const KEYWORD_DOCS: Record<string, string>;
+export declare function getHoverInfo(word: string, index: ProgramIndex): Hover | null;
+export declare function formatType(type: TypeExpr): string;
+export { formatExpr } from '../../format.js';