@dot-agent/language-server 0.4.0 → 0.4.1

package/README.md

@@ -4,7 +4,7 @@ A standalone [Language Server Protocol (LSP)](https://microsoft.github.io/langua
 
 ## Features
 
-| Capability | `.agent` | `.behavior` |
+| Capability | `.description` | `.behavior` |
 |---|---|---|
 | **Hover** | Keyword documentation | Keyword documentation |
 | **Completion** | Manifest keywords, custom types | Keywords, state names, memory domains (`context.`, `session.`, …) |
@@ -36,7 +36,7 @@ A standalone [Language Server Protocol (LSP)](https://microsoft.github.io/langua
 
 The server speaks LSP over `stdio`. Each editor starts it as a subprocess and communicates via JSON-RPC messages.
 
-All structural analysis uses the **tree-sitter** parse trees from [`@dot-agent/tree-sitter-agent`](https://github.com/daniloborges/tree-sitter-agent). `parser.js` initializes the WASM-based parsers during `initialize` and maintains a per-document AST cache with incremental reparse.
+All structural analysis uses the **tree-sitter** parse trees from [`@dot-agent/tree-sitter`](https://github.com/dot-agent-spec/tree-sitter). `parser.js` initializes the WASM-based parsers during `initialize` and maintains a per-document AST cache with incremental reparse.
 
 ## Prerequisites
 
@@ -84,7 +84,7 @@ if not configs.agent_dsl then
   configs.agent_dsl = {
     default_config = {
       cmd = { 'node', '/path/to/language-server/server.js', '--stdio' },
-      filetypes = { 'agent', 'behavior' },
+      filetypes = { 'description', 'behavior' },
       root_dir = lspconfig.util.root_pattern('.git'),
     },
   }
@@ -97,7 +97,7 @@ lspconfig.agent_dsl.setup {}
 
 ```toml
 [[language]]
-name = "agent"
+name = "description"
 language-servers = ["agent-dsl-lsp"]
 
 [[language]]

package/features/definition.js

@@ -16,7 +16,33 @@
 
 'use strict';
 
-const { nodesOfType, nodeToRange, wordAtPosition } = require('../parser');
+const fs = require('fs');
+const { fileURLToPath, pathToFileURL } = require('url');
+const path = require('path');
+const { nodesOfType, nodeToRange, wordAtPosition, parseText } = require('../parser');
+
+// Busca recursiva de state_decl em arquivos mergeados.
+// visited (Set<absPath>) evita loops em grafos de merge circulares.
+function findStateInMerges(tree, docDir, word, visited = new Set()) {
+    for (const mergeNode of nodesOfType(tree, 'merge_decl')) {
+        const pathNode = mergeNode.childForFieldName('path');
+        if (!pathNode) continue;
+        const filename = pathNode.text.replace(/^"|"$/g, '');
+        const absPath = path.resolve(docDir, filename);
+        if (visited.has(absPath)) continue;
+        visited.add(absPath);
+        let mergedText;
+        try { mergedText = fs.readFileSync(absPath, 'utf8'); } catch { continue; }
+        const mergedTree = parseText('behavior', mergedText);
+        if (!mergedTree) continue;
+        const found = nodesOfType(mergedTree, 'state_decl')
+            .find(n => n.childForFieldName('name')?.text === word);
+        if (found) return { uri: pathToFileURL(absPath).toString(), range: nodeToRange(found) };
+        const sub = findStateInMerges(mergedTree, path.dirname(absPath), word, visited);
+        if (sub) return sub;
+    }
+    return null;
+}
 
 function provideDefinition(langId, tree, text, uri, position) {
     if (!tree) return null;
@@ -24,19 +50,25 @@ function provideDefinition(langId, tree, text, uri, position) {
     const { word } = wordAtPosition(text, position.line, position.character);
     if (!word) return null;
 
-    let targetNode = null;
-
     if (langId === 'behavior') {
-        targetNode = nodesOfType(tree, 'state_decl')
+        const local = nodesOfType(tree, 'state_decl')
             .find(n => n.childForFieldName('name')?.text === word);
-    } else if (langId === 'description') {
+        if (local) return { uri, range: nodeToRange(local) };
+        try {
+            const docDir = path.dirname(fileURLToPath(uri));
+            return findStateInMerges(tree, docDir, word) ?? null;
+        } catch { return null; }
+    }
+
+    if (langId === 'description') {
         if (!/^[A-Z]/.test(word) && !word.includes('.')) return null;
-        targetNode = nodesOfType(tree, 'type_decl')
+        const targetNode = nodesOfType(tree, 'type_decl')
             .find(n => n.childForFieldName('name')?.text === word);
+        if (!targetNode) return null;
+        return { uri, range: nodeToRange(targetNode) };
     }
 
-    if (!targetNode) return null;
-    return { uri, range: nodeToRange(targetNode) };
+    return null;
 }
 
 module.exports = { provideDefinition };

package/features/diagnostics.js

@@ -16,8 +16,11 @@
 
 'use strict';
 
+const fs = require('fs');
+const { fileURLToPath } = require('url');
+const path = require('path');
 const { DiagnosticSeverity } = require('vscode-languageserver');
-const { nodesOfType, nodeToRange } = require('../parser');
+const { nodesOfType, nodeToRange, parseText } = require('../parser');
 
 const STRICT_BLOCK_TYPES = {
     input_block:        'input',
@@ -70,17 +73,87 @@ function diagnoseDescription(tree, text) {
     return diagnostics;
 }
 
-function diagnoseBehavior(tree) {
+// Coleta recursivamente todos os state names declarados nos arquivos mergeados.
+// visited (Set<absPath>) evita loops em grafos de merge circulares.
+function collectMergedStates(tree, docDir, definedStates, visited = new Set()) {
+    for (const mergeNode of nodesOfType(tree, 'merge_decl')) {
+        const pathNode = mergeNode.childForFieldName('path');
+        if (!pathNode) continue;
+        const filename = pathNode.text.replace(/^"|"$/g, '');
+        const absPath = path.resolve(docDir, filename);
+        if (visited.has(absPath)) continue;
+        visited.add(absPath);
+        let mergedText;
+        try { mergedText = fs.readFileSync(absPath, 'utf8'); } catch { continue; }
+        const mergedTree = parseText('behavior', mergedText);
+        if (!mergedTree) continue;
+        nodesOfType(mergedTree, 'state_decl').forEach(n => {
+            const name = n.childForFieldName('name')?.text;
+            if (name) definedStates.add(name);
+        });
+        collectMergedStates(mergedTree, path.dirname(absPath), definedStates, visited);
+    }
+}
+
+// Coleta erros de sintaxe (nós ERROR e MISSING) para que a causa real apareça
+// sublinhada no editor, e não apenas o efeito colateral (ex.: "state not defined").
+// Reporta apenas o ERROR mais externo de cada ramo, e tokens MISSING (ex.: falta 'to').
+function collectSyntaxErrors(root, diagnostics) {
+    const seen = new Set();
+
+    function push(node, message) {
+        const key = `${node.startIndex}:${node.endIndex}:${message}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        diagnostics.push({
+            range: nodeToRange(node),
+            message,
+            severity: DiagnosticSeverity.Error,
+            source: 'behavior-dsl',
+        });
+    }
+
+    function walk(node) {
+        if (node.isMissing) {
+            push(node, `Syntax error: missing '${node.type}'.`);
+            return;
+        }
+        if (node.type === 'ERROR') {
+            // Reporta o ERROR mais profundo (folha) para apontar o token preciso,
+            // em vez do span externo que pode embrulhar o bloco inteiro.
+            const hasNestedError = node.descendantsOfType('ERROR').some(e => e.id !== node.id);
+            if (!hasNestedError) {
+                const snippet = node.text.replace(/\s+/g, ' ').trim().slice(0, 40);
+                push(node, snippet ? `Syntax error near '${snippet}'.` : 'Syntax error.');
+                return;
+            }
+            // tem ERROR aninhado → desce para reportar o(s) mais específico(s)
+        }
+        for (const child of node.children) walk(child);
+    }
+
+    walk(root);
+}
+
+function diagnoseBehavior(tree, docUri) {
     const diagnostics = [];
 
+    // ── Rule 0: Syntax errors (ERROR / MISSING nodes) ─────────────────────────
+    collectSyntaxErrors(tree.rootNode, diagnostics);
+
     // ── Rule 1: Dangling transitions ──────────────────────────────────────────
-    // Collect all defined state names (from both oriented_state_body and setup_state_body)
     const definedStates = new Set(
         nodesOfType(tree, 'state_decl')
             .map(n => n.childForFieldName('name')?.text)
             .filter(Boolean)
     );
 
+    // Enriquecer com estados de arquivos mergeados (recursivo, anti-loop)
+    try {
+        const docDir = path.dirname(fileURLToPath(docUri));
+        collectMergedStates(tree, docDir, definedStates);
+    } catch { /* URI inválida ou sem acesso — diagnostica apenas com estados locais */ }
+
     function checkTransitionTarget(stateNode) {
         if (!stateNode) return;
         const target = stateNode.text;
@@ -129,10 +202,10 @@ function diagnoseBehavior(tree) {
     return diagnostics;
 }
 
-function diagnose(langId, tree, text) {
+function diagnose(langId, tree, text, uri) {
     if (!tree) return [];
     if (langId === 'description') return diagnoseDescription(tree, text);
-    if (langId === 'behavior')  return diagnoseBehavior(tree);
+    if (langId === 'behavior')  return diagnoseBehavior(tree, uri);
     return [];
 }
 

package/features/graph.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+const { nodesOfType } = require('../parser');
+
+function extractBehaviorGraph(tree) {
+    const states = nodesOfType(tree, 'state_decl')
+        .map(n => n.childForFieldName('name')?.text)
+        .filter(Boolean);
+
+    const transitions = [];
+    const seen = new Set();
+    for (const stateNode of nodesOfType(tree, 'state_decl')) {
+        const from = stateNode.childForFieldName('name')?.text;
+        if (!from) continue;
+        for (const t of stateNode.descendantsOfType('transition_stmt')) {
+            const to = t.childForFieldName('state')?.text;
+            if (to) {
+                const key = `${from}→${to}`;
+                if (!seen.has(key)) { seen.add(key); transitions.push({ from, to }); }
+            }
+        }
+    }
+
+    const entryPoints = [];
+    for (const triggerNode of nodesOfType(tree, 'trigger_decl')) {
+        // event field is a quoted_string WITHOUT surrounding quotes (quotes are literals in the grammar rule)
+        const eventText = triggerNode.childForFieldName('event')?.text;
+        for (const t of triggerNode.descendantsOfType('transition_stmt')) {
+            const to = t.childForFieldName('state')?.text;
+            if (eventText && to) entryPoints.push({ event: eventText, to });
+        }
+    }
+
+    return { states, transitions, entryPoints };
+}
+
+module.exports = { extractBehaviorGraph };

package/features/links.js

@@ -20,6 +20,16 @@ const { fileURLToPath, pathToFileURL } = require('url');
 const path = require('path');
 const { nodesOfType, nodeToRange } = require('../parser');
 
+// Detecta se um nó bare_string representa um caminho de arquivo.
+// Usa o subtipo do tree-sitter (filename) como primeira fonte de verdade;
+// cai no regex do grammar.js como fallback para ambientes que não expõem subnós.
+// O padrão aceita: extensão simples (a.md), dupla (a.b.persona), longa (.behavior)
+// e exclui texto livre (que tem espaços/pontuação fora do charset).
+function isFilename(node) {
+    if (node.firstNamedChild?.type === 'filename') return true;
+    return /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/.test(node.text.replace(/^"|"$/g, ''));
+}
+
 function provideDocumentLinks(langId, tree, docUri) {
     if (!tree) return [];
 
@@ -32,8 +42,8 @@ function provideDocumentLinks(langId, tree, docUri) {
 
     const links = [];
 
-    function addLink(fileNode, rawText) {
-        const filename = rawText.replace(/^"|"$/g, '');   // strip optional quotes
+    function addFileLink(fileNode, rawText) {
+        const filename = rawText.replace(/^"|"$/g, '');
         if (!filename) return;
         links.push({
             range: nodeToRange(fileNode),
@@ -41,23 +51,41 @@ function provideDocumentLinks(langId, tree, docUri) {
         });
     }
 
+    function addUrlLink(uriNode) {
+        const url = uriNode.text.trim();
+        if (!url) return;
+        links.push({ range: nodeToRange(uriNode), target: url });
+    }
+
     if (langId === 'description') {
         for (const node of nodesOfType(tree, 'behavior_block')) {
             const fileNode = node.childForFieldName('file');
-            if (fileNode) addLink(fileNode, fileNode.text);
+            if (fileNode) addFileLink(fileNode, fileNode.text);
+        }
+        for (const node of nodesOfType(tree, 'persona_block')) {
+            const fileNode = node.childForFieldName('file');
+            if (fileNode && isFilename(fileNode)) addFileLink(fileNode, fileNode.text);
+        }
+        for (const node of nodesOfType(tree, 'category_prop')) {
+            const uriNode = node.childForFieldName('uri');
+            if (uriNode) addUrlLink(uriNode);
+        }
+        for (const node of nodesOfType(tree, 'concept_prop')) {
+            const uriNode = node.childForFieldName('uri');
+            if (uriNode) addUrlLink(uriNode);
         }
     }
 
     if (langId === 'behavior') {
         for (const node of nodesOfType(tree, 'merge_decl')) {
             const pathNode = node.childForFieldName('path');
-            if (pathNode) addLink(pathNode, pathNode.text);
+            if (pathNode) addFileLink(pathNode, pathNode.text);
         }
         for (const node of nodesOfType(tree, 'run_stmt')) {
             const runTypeNode = node.childForFieldName('type');
             if (runTypeNode?.text !== 'script') continue;
             const targetNode = node.childForFieldName('target');
-            if (targetNode) addLink(targetNode, targetNode.text);
+            if (targetNode) addFileLink(targetNode, targetNode.text);
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dot-agent/language-server",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "LSP server for .agent DSL files",
   "license": "Apache-2.0",
   "author": "Danilo Borges <contato@daniloborg.es>",
@@ -27,7 +27,7 @@
     "start": "node server.js --stdio"
   },
   "dependencies": {
-    "@dot-agent/tree-sitter": "^0.3.4",
+    "@dot-agent/tree-sitter": "^0.3.6",
     "vscode-languageserver": "^10.0.0",
     "vscode-languageserver-textdocument": "^1.0.12",
     "web-tree-sitter": "^0.26.9"

package/parser.js

@@ -53,6 +53,12 @@ function evict(uri) {
     cache.delete(uri);
 }
 
+function parseText(langId, text) {
+    const parser = langId === 'behavior' ? behaviorParser : descriptionParser;
+    if (!parser) return null;
+    return parser.parse(text);
+}
+
 // ── AST helpers ──────────────────────────────────────────────────────────────
 
 function nodesOfType(tree, type) {
@@ -116,6 +122,7 @@ function getContextNode(tree, offset) {
 module.exports = {
     initParsers,
     parse,
+    parseText,
     evict,
     nodesOfType,
     nodeAtOffset,

package/server.js

@@ -25,7 +25,7 @@ const {
 } = require('vscode-languageserver/node');
 const { TextDocument } = require('vscode-languageserver-textdocument');
 
-const { initParsers, parse, evict } = require('./parser');
+const { initParsers, parse, evict, nodesOfType } = require('./parser');
 
 const { provideHover }          = require('./features/hover');
 const { provideCompletions }    = require('./features/completions');
@@ -36,6 +36,7 @@ const { provideReferences }     = require('./features/references');
 const { provideRenameEdits }    = require('./features/rename');
 const { format }                = require('./features/formatting');
 const { provideDocumentLinks }  = require('./features/links');
+const { extractBehaviorGraph }  = require('./features/graph');
 
 const connection = createConnection(ProposedFeatures.all);
 const documents  = new TextDocuments(TextDocument);
@@ -73,7 +74,7 @@ function validate(doc) {
     const langId = doc.languageId;
     if (langId !== 'description' && langId !== 'behavior') return;
     const tree = getTree(doc);
-    const diagnostics = diagnose(langId, tree, doc.getText());
+    const diagnostics = diagnose(langId, tree, doc.getText(), doc.uri);
     connection.sendDiagnostics({ uri: doc.uri, diagnostics });
 }
 
@@ -163,6 +164,33 @@ connection.onDocumentFormatting(({ textDocument }) => {
     return format(doc.languageId, doc.getText());
 });
 
+// ── Behavior Graph (custom request) ──────────────────────────────────────────
+
+connection.onRequest('agent/behaviorGraph', ({ uri }) => {
+    const doc = documents.get(uri);
+    if (!doc || doc.languageId !== 'behavior') return null;
+    const tree = getTree(doc);
+    return tree ? extractBehaviorGraph(tree) : null;
+});
+
+// ── Current State at Position (custom request) ────────────────────────────────
+
+connection.onRequest('agent/currentState', ({ uri, position }) => {
+    const doc = documents.get(uri);
+    if (!doc || doc.languageId !== 'behavior') return null;
+    const tree = getTree(doc);
+    if (!tree) return null;
+    const line = position.line;
+    let result = null;
+    for (const node of nodesOfType(tree, 'state_decl')) {
+        if (node.startPosition.row > line) break;
+        if (node.startPosition.row <= line && node.endPosition.row >= line) {
+            result = node.childForFieldName('name')?.text ?? null;
+        }
+    }
+    return result;
+});
+
 // ── Start ────────────────────────────────────────────────────────────────────
 
 documents.listen(connection);