@jsleekr/graft 5.7.0

package/dist/lsp/server.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, CodeActionKind, } from 'vscode-languageserver/node';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { compileToProgram } from '../compiler.js';
+import { Lexer } from '../lexer/lexer.js';
+import { Parser } from '../parser/parser.js';
+import { toDiagnostics, getHoverInfo, getDefinitionLocation, getWordAtPosition, getCompletions, buildAutoImportActions, getDocumentSymbols, isRenameable, buildRenameEdits, isReferable, findReferences } from './features/index.js';
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+const MAX_CACHE_SIZE = 50;
+const cache = new Map();
+function evictIfNeeded() {
+    if (cache.size <= MAX_CACHE_SIZE)
+        return;
+    let oldestKey = '';
+    let oldestTime = Infinity;
+    for (const [key, val] of cache) {
+        if (val.lastAccess < oldestTime) {
+            oldestTime = val.lastAccess;
+            oldestKey = key;
+        }
+    }
+    if (oldestKey)
+        cache.delete(oldestKey);
+}
+function touchCache(uri) {
+    const entry = cache.get(uri);
+    if (entry) {
+        entry.lastAccess = Date.now();
+        return entry;
+    }
+    return undefined;
+}
+const debounceTimers = new Map();
+// Track import dependencies: importedFile → Set of URIs that import it
+const importDeps = new Map();
+// Workspace export cache for auto-import code actions
+const workspaceExports = new Map();
+let workspaceRoot = null;
+let workspaceScanDone = false;
+connection.onInitialize((params) => {
+    const folders = params.workspaceFolders;
+    if (folders && folders.length > 0) {
+        workspaceRoot = fileURLToPath(folders[0].uri);
+    }
+    else if (params.rootUri) {
+        workspaceRoot = fileURLToPath(params.rootUri);
+    }
+    return {
+        capabilities: {
+            textDocumentSync: TextDocumentSyncKind.Full,
+            hoverProvider: true,
+            definitionProvider: true,
+            completionProvider: {
+                triggerCharacters: ['.', '[', '{'],
+            },
+            documentSymbolProvider: true,
+            codeActionProvider: {
+                codeActionKinds: [CodeActionKind.QuickFix],
+            },
+            referencesProvider: true,
+            renameProvider: {
+                prepareProvider: true,
+            },
+        },
+    };
+});
+function validateDocument(doc) {
+    const uri = doc.uri;
+    const filePath = fileURLToPath(uri);
+    try {
+        const result = compileToProgram(doc.getText(), filePath);
+        const diagnostics = toDiagnostics(result.errors, result.warnings);
+        connection.sendDiagnostics({ uri, diagnostics });
+        if (result.program && result.index) {
+            cache.set(uri, { program: result.program, index: result.index, lastAccess: Date.now() });
+            evictIfNeeded();
+            // Track import dependencies
+            for (const imp of result.program.imports) {
+                if (imp.resolvedPath) {
+                    const depUri = pathToFileURL(imp.resolvedPath).toString();
+                    let dependents = importDeps.get(depUri);
+                    if (!dependents) {
+                        dependents = new Set();
+                        importDeps.set(depUri, dependents);
+                    }
+                    dependents.add(uri);
+                }
+            }
+        }
+    }
+    catch {
+        connection.sendDiagnostics({ uri, diagnostics: [] });
+    }
+}
+documents.onDidChangeContent((change) => {
+    const uri = change.document.uri;
+    const existing = debounceTimers.get(uri);
+    if (existing)
+        clearTimeout(existing);
+    debounceTimers.set(uri, setTimeout(() => {
+        debounceTimers.delete(uri);
+        const doc = documents.get(uri);
+        if (doc) {
+            validateDocument(doc);
+            // Update workspace export cache for changed file
+            if (uri.startsWith('file:')) {
+                const changedPath = fileURLToPath(uri);
+                if (changedPath.endsWith('.gft'))
+                    parseAndCacheExports(changedPath);
+            }
+            // Invalidate dependents of this file
+            const dependents = importDeps.get(uri);
+            if (dependents) {
+                for (const depUri of dependents) {
+                    const depDoc = documents.get(depUri);
+                    if (depDoc)
+                        validateDocument(depDoc);
+                }
+            }
+        }
+    }, 200));
+});
+documents.onDidClose((e) => {
+    cache.delete(e.document.uri);
+    connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+});
+connection.onHover((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const state = touchCache(params.textDocument.uri);
+    if (!doc || !state)
+        return null;
+    const word = getWordAtPosition(doc.getText(), params.position.line, params.position.character);
+    if (!word)
+        return null;
+    return getHoverInfo(word, state.index);
+});
+connection.onDefinition((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const state = touchCache(params.textDocument.uri);
+    if (!doc || !state)
+        return null;
+    const word = getWordAtPosition(doc.getText(), params.position.line, params.position.character);
+    if (!word)
+        return null;
+    return getDefinitionLocation(word, state.index, params.textDocument.uri);
+});
+connection.onCompletion((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc)
+        return [];
+    const state = touchCache(params.textDocument.uri);
+    const resolveImportNames = (importPath) => {
+        try {
+            const currentFilePath = fileURLToPath(params.textDocument.uri);
+            let resolved = path.resolve(path.dirname(currentFilePath), importPath);
+            if (!resolved.endsWith('.gft'))
+                resolved += '.gft';
+            const source = fs.readFileSync(resolved, 'utf-8');
+            const tokens = new Lexer(source).tokenize();
+            const result = new Parser(tokens).parse();
+            return [
+                ...result.program.contexts.map(c => c.name),
+                ...result.program.nodes.map(n => n.name),
+            ];
+        }
+        catch {
+            return [];
+        }
+    };
+    return getCompletions(doc.getText(), params.position.line, params.position.character, state ?? null, resolveImportNames);
+});
+connection.onDocumentSymbol((params) => {
+    const state = touchCache(params.textDocument.uri);
+    if (!state)
+        return [];
+    return getDocumentSymbols(state.program, state.index);
+});
+// --- Workspace Export Scanning ---
+function scanWorkspaceExports(rootDir, excludeFile) {
+    try {
+        scanDir(rootDir, excludeFile);
+    }
+    catch { /* best-effort */ }
+}
+function scanDir(dir, excludeFile) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist')
+            continue;
+        const full = path.join(dir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory())
+            scanDir(full, excludeFile);
+        else if (entry.endsWith('.gft') && full !== excludeFile)
+            parseAndCacheExports(full);
+    }
+}
+function parseAndCacheExports(filePath) {
+    try {
+        // Prefer open document buffer over disk
+        const uri = pathToFileURL(filePath).toString();
+        const openDoc = documents.get(uri);
+        const source = openDoc ? openDoc.getText() : fs.readFileSync(filePath, 'utf-8');
+        const tokens = new Lexer(source).tokenize();
+        const { program } = new Parser(tokens).parse();
+        workspaceExports.set(filePath, [
+            ...program.contexts.map(c => c.name),
+            ...program.nodes.map(n => n.name),
+        ]);
+    }
+    catch { /* skip unparseable files */ }
+}
+// --- Workspace Helpers ---
+function ensureWorkspaceScan(currentFilePath) {
+    if (workspaceRoot && !workspaceScanDone) {
+        scanWorkspaceExports(workspaceRoot, currentFilePath);
+        workspaceScanDone = true;
+    }
+}
+function collectWorkspaceFileTexts(currentUri, currentFilePath, filter) {
+    ensureWorkspaceScan(currentFilePath);
+    const files = new Map();
+    if (!workspaceRoot)
+        return files;
+    for (const [filePath] of workspaceExports) {
+        const fileUri = pathToFileURL(filePath).toString();
+        if (fileUri === currentUri)
+            continue;
+        const openDoc = documents.get(fileUri);
+        let fileText;
+        try {
+            fileText = openDoc ? openDoc.getText() : fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        if (filter && !filter(fileText, filePath))
+            continue;
+        files.set(filePath, { text: fileText, uri: fileUri });
+    }
+    return files;
+}
+// --- Code Actions ---
+connection.onCodeAction((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    if (!doc || !params.textDocument.uri.startsWith('file:'))
+        return [];
+    const currentFilePath = fileURLToPath(params.textDocument.uri);
+    ensureWorkspaceScan(currentFilePath);
+    if (!workspaceRoot)
+        return [];
+    return buildAutoImportActions(doc.getText(), params.textDocument.uri, currentFilePath, params.context.diagnostics, workspaceExports);
+});
+// --- Rename ---
+connection.onPrepareRename((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const state = touchCache(params.textDocument.uri);
+    if (!doc || !state)
+        return null;
+    const word = getWordAtPosition(doc.getText(), params.position.line, params.position.character);
+    if (!word || !isRenameable(word, state.index))
+        return null;
+    // Return the range of the word under cursor
+    const lines = doc.getText().split('\n');
+    const lineText = lines[params.position.line] ?? '';
+    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 (params.position.character >= start && params.position.character < end) {
+            return {
+                start: { line: params.position.line, character: start },
+                end: { line: params.position.line, character: end },
+            };
+        }
+    }
+    return null;
+});
+connection.onRenameRequest((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const state = touchCache(params.textDocument.uri);
+    if (!doc || !state)
+        return null;
+    const word = getWordAtPosition(doc.getText(), params.position.line, params.position.character);
+    if (!word || !isRenameable(word, state.index))
+        return null;
+    const currentFilePath = fileURLToPath(params.textDocument.uri);
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const importPattern = new RegExp(`import\\s*\\{[^}]*\\b${escaped}\\b[^}]*\\}`);
+    const importingFiles = collectWorkspaceFileTexts(params.textDocument.uri, currentFilePath, (text) => importPattern.test(text));
+    const result = buildRenameEdits(word, params.newName, doc.getText(), params.textDocument.uri, currentFilePath, importingFiles);
+    if (!result || 'error' in result)
+        return null;
+    return result;
+});
+connection.onReferences((params) => {
+    const doc = documents.get(params.textDocument.uri);
+    const state = touchCache(params.textDocument.uri);
+    if (!doc || !state)
+        return null;
+    const word = getWordAtPosition(doc.getText(), params.position.line, params.position.character);
+    if (!word || !isReferable(word, state.index))
+        return null;
+    const currentFilePath = fileURLToPath(params.textDocument.uri);
+    const wsFiles = collectWorkspaceFileTexts(params.textDocument.uri, currentFilePath, (text) => text.includes(word));
+    const results = findReferences(word, doc.getText(), params.textDocument.uri, state.index, params.context.includeDeclaration, wsFiles);
+    return results.length > 0 ? results : null;
+});
+documents.listen(connection);
+connection.listen();

package/dist/parser/ast.d.ts

@@ -0,0 +1,244 @@
+import { SourceLocation } from '../errors/diagnostics.js';
+export type TemplatePart = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'expr';
+    value: Expr;
+};
+export type Expr = {
+    kind: 'literal';
+    value: string | number | boolean;
+    location: SourceLocation;
+} | {
+    kind: 'field_access';
+    segments: string[];
+    location: SourceLocation;
+} | {
+    kind: 'binary';
+    op: '+' | '-' | '/' | '*' | '%' | '<' | '>' | '<=' | '>=' | '==' | '!=' | '&&' | '||' | '??';
+    left: Expr;
+    right: Expr;
+    location: SourceLocation;
+} | {
+    kind: 'unary';
+    op: '-' | '!';
+    operand: Expr;
+    location: SourceLocation;
+} | {
+    kind: 'group';
+    inner: Expr;
+    location: SourceLocation;
+} | {
+    kind: 'call';
+    name: string;
+    args: Expr[];
+    location: SourceLocation;
+} | {
+    kind: 'template';
+    parts: TemplatePart[];
+    location: SourceLocation;
+} | {
+    kind: 'conditional';
+    condition: Expr;
+    consequent: Expr;
+    alternate: Expr;
+    location: SourceLocation;
+};
+/** Built-in expression functions with metadata for type checking and LSP. */
+export declare const BUILTIN_FUNCTIONS: Record<string, {
+    arity: number;
+    returnType: 'number' | 'string' | 'unknown';
+    signature: string;
+    description: string;
+}>;
+export interface ImportDecl {
+    names: string[];
+    path: string;
+    resolvedPath?: string;
+    location: SourceLocation;
+}
+export interface MemoryDecl {
+    name: string;
+    maxTokens: number;
+    storage: 'file';
+    fields: Field[];
+    location: SourceLocation;
+}
+export interface Program {
+    imports: ImportDecl[];
+    memories: MemoryDecl[];
+    contexts: ContextDecl[];
+    nodes: NodeDecl[];
+    edges: EdgeDecl[];
+    graphs: GraphDecl[];
+}
+export interface ContextDecl {
+    name: string;
+    maxTokens: number;
+    fields: Field[];
+    location: SourceLocation;
+    sourceFile?: string;
+}
+export interface NodeDecl {
+    name: string;
+    model: string;
+    budgetIn: number;
+    budgetOut: number;
+    reads: ContextRef[];
+    tools: string[];
+    writes: WriteRef[];
+    onFailure?: FailureStrategy;
+    produces: ProducesDecl;
+    location: SourceLocation;
+    sourceFile?: string;
+}
+export interface ProducesDecl {
+    name: string;
+    fields: Field[];
+    location: SourceLocation;
+}
+export interface EdgeDecl {
+    source: string;
+    target: EdgeTarget;
+    transforms: Transform[];
+    location: SourceLocation;
+}
+export type EdgeTarget = {
+    kind: 'direct';
+    node: string;
+} | {
+    kind: 'conditional';
+    branches: ConditionalBranch[];
+};
+export interface ConditionalBranch {
+    /** When undefined, this branch represents the `else` case (default target). */
+    condition?: Expr;
+    target: string;
+}
+export type FlowNode = {
+    kind: 'node';
+    name: string;
+    location?: SourceLocation;
+} | {
+    kind: 'parallel';
+    branches: string[];
+    location?: SourceLocation;
+} | {
+    kind: 'foreach';
+    source: string;
+    field: string;
+    binding: string;
+    maxIterations: number;
+    body: FlowNode[];
+    location?: SourceLocation;
+} | {
+    kind: 'let';
+    name: string;
+    value: Expr;
+    location?: SourceLocation;
+} | {
+    kind: 'graph_call';
+    name: string;
+    args: GraphArg[];
+    location?: SourceLocation;
+};
+export interface GraphDecl {
+    name: string;
+    input: string;
+    output: string;
+    budget: number;
+    params: GraphParam[];
+    flow: FlowNode[];
+    location: SourceLocation;
+}
+export interface GraphParam {
+    name: string;
+    type: 'Node' | 'Int' | 'String' | 'Bool';
+    default?: string | number | boolean;
+    location: SourceLocation;
+}
+export interface GraphArg {
+    name: string;
+    value: Expr;
+    location: SourceLocation;
+}
+export interface Field {
+    name: string;
+    type: TypeExpr;
+    location: SourceLocation;
+}
+export type TypeExpr = {
+    kind: 'primitive';
+    name: 'String' | 'Int' | 'Float' | 'Bool';
+} | {
+    kind: 'primitive_range';
+    name: 'Float';
+    min: number;
+    max: number;
+} | {
+    kind: 'list';
+    element: TypeExpr;
+} | {
+    kind: 'map';
+    key: TypeExpr;
+    value: TypeExpr;
+} | {
+    kind: 'optional';
+    inner: TypeExpr;
+} | {
+    kind: 'token_bounded';
+    inner: TypeExpr;
+    max: number;
+} | {
+    kind: 'enum';
+    values: string[];
+} | {
+    kind: 'struct';
+    name: string;
+    fields: Field[];
+} | {
+    kind: 'domain';
+    name: 'FilePath' | 'FileDiff' | 'TestFile' | 'IssueRef';
+};
+export interface ContextRef {
+    context: string;
+    field?: string[];
+    location: SourceLocation;
+}
+export interface WriteRef {
+    memory: string;
+    field?: string;
+    location: SourceLocation;
+}
+export type Transform = {
+    type: 'select';
+    fields: string[];
+} | {
+    type: 'filter';
+    field: string;
+    condition: Expr;
+} | {
+    type: 'drop';
+    field: string;
+} | {
+    type: 'compact';
+} | {
+    type: 'truncate';
+    tokens: number;
+};
+export type FailureStrategy = {
+    type: 'retry';
+    max: number;
+} | {
+    type: 'fallback';
+    node: string;
+} | {
+    type: 'retry_then_fallback';
+    max: number;
+    node: string;
+} | {
+    type: 'skip';
+} | {
+    type: 'abort';
+};

package/dist/parser/ast.js

@@ -0,0 +1,10 @@
+/** Built-in expression functions with metadata for type checking and LSP. */
+export const BUILTIN_FUNCTIONS = {
+    len: { arity: 1, returnType: 'number', signature: 'len(value) -> number', description: 'Returns the length of an array or string.' },
+    max: { arity: 2, returnType: 'number', signature: 'max(a, b) -> number', description: 'Returns the larger of two numbers.' },
+    min: { arity: 2, returnType: 'number', signature: 'min(a, b) -> number', description: 'Returns the smaller of two numbers.' },
+    str: { arity: 1, returnType: 'string', signature: 'str(value) -> string', description: 'Converts a value to its string representation. Objects are JSON-stringified.' },
+    abs: { arity: 1, returnType: 'number', signature: 'abs(n) -> number', description: 'Returns the absolute value of a number.' },
+    round: { arity: 1, returnType: 'number', signature: 'round(n) -> number', description: 'Rounds a number to the nearest integer.' },
+    keys: { arity: 1, returnType: 'unknown', signature: 'keys(obj) -> array', description: 'Returns the keys of an object as an array.' },
+};

package/dist/parser/parser.d.ts

@@ -0,0 +1,95 @@
+import { Token } from '../lexer/tokens.js';
+import { GraftError } from '../errors/diagnostics.js';
+import { Program } from './ast.js';
+export interface ParseResult {
+    program: Program;
+    errors: GraftError[];
+}
+export declare class Parser {
+    private readonly tokens;
+    private pos;
+    private errors;
+    private static readonly MAX_ERRORS;
+    private static readonly DECLARATION_KEYWORDS;
+    constructor(tokens: Token[]);
+    parse(): ParseResult;
+    private synchronize;
+    private parseImportDecl;
+    private parseMemoryDecl;
+    private parseContext;
+    private parseNode;
+    private parseProduces;
+    private parseContextRefList;
+    private parseWriteRefList;
+    private parseIdentifierList;
+    private parseFailureStrategy;
+    private parseEdge;
+    private parseConditionalTarget;
+    private parseTransform;
+    private parseCondition;
+    private parseConditionValue;
+    private parseGraph;
+    private parseGraphParam;
+    /**
+     * Parse a sequence of flow nodes separated by arrows.
+     * When insideBlock=true, stops when no more arrows (next token should be RBrace).
+     * When insideBlock=false, expects -> done to terminate.
+     */
+    private parseFlowNodes;
+    /**
+     * Parse a single flow node: identifier, parallel block, foreach block,
+     * let binding, or graph call.
+     */
+    private parseFlowNode;
+    private parseLetStep;
+    private parseGraphCall;
+    /**
+     * parallel { SecurityReviewer  PerformanceReviewer  StyleReviewer }
+     *
+     * Branches are whitespace-separated identifiers (no commas required).
+     * Optional commas are accepted for user convenience.
+     */
+    private parseParallelStep;
+    /**
+     * foreach(Planner.output.steps as step, max_iterations: 5) {
+     *   Implementer -> Verifier
+     * }
+     */
+    private parseForeachStep;
+    private parseExpr;
+    private parseNullCoalesce;
+    private parseLogicalOr;
+    private parseLogicalAnd;
+    private parseComparison;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseUnary;
+    private parseTemplateParts;
+    private parsePrimary;
+    private parseType;
+    private parseTypeOrInlineStruct;
+    private parseFields;
+    private parseTokenValue;
+    private parseIntValue;
+    private parseNumericValue;
+    /**
+     * Strict identifier: only accepts TokenType.Identifier.
+     * Used for declaration names (context, node, edge, graph), produces names,
+     * context ref context-part, graph flow nodes, edge source/target.
+     * These are PascalCase by convention and must not collide with keywords.
+     */
+    private expectIdentifier;
+    /**
+     * Permissive identifier: accepts TokenType.Identifier OR any keyword token.
+     * Used for field names, tool names, enum values, transform field arguments,
+     * condition field names -- positions where a keyword-like word is valid as a name.
+     */
+    private expectIdentifierOrKeyword;
+    private expect;
+    private check;
+    private current;
+    private advance;
+    private peekType;
+    private isAtEnd;
+    private error;
+}