@dot-agent/language-server 0.3.1 → 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/completions.js

@@ -19,9 +19,9 @@
 const { CompletionItemKind } = require('vscode-languageserver');
 const { nodesOfType, positionToOffset, getContextNode } = require('../parser');
 
-const BEHAVIOR_TOP_KW   = ['state', 'merge', 'on event', 'on intent', 'on offtopic', 'on fallback'];
-const BEHAVIOR_BLOCK_KW = ['guide', 'teach', 'goal', 'interact', 'run', 'transition', 'set', 'if', 'else', 'after', 'parallel', 'apply', 'remove', 'on intent', 'on offtopic', 'on fallback', 'on complete', 'on failed'];
-const AGENT_TOP_KW  = ['agent', 'domain', 'license', 'terms', 'privacy', 'description', 'behavior', 'requires', 'input', 'capabilities', 'output', 'type', 'concept', 'schema'];
+const BEHAVIOR_TOP_KW   = ['state', 'merge', 'on event', 'on intent', 'on offtopic'];
+const BEHAVIOR_BLOCK_KW = ['guide', 'teach', 'goal', 'interact', 'run', 'transition', 'set', 'if', 'else', 'end', 'after', 'parallel', 'apply', 'remove', 'on intent', 'on offtopic', 'on failure', 'on success'];
+const DESCRIPTION_TOP_KW  = ['agent', 'domain', 'license', 'terms', 'privacy', 'description', 'behavior', 'requires', 'input', 'capabilities', 'output', 'type', 'concept'];
 const STRICT_BLOCKS = new Set(['input_block', 'output_block', 'requires_block', 'capabilities_block']);
 
 function kw(label) {
@@ -59,7 +59,7 @@ function provideCompletions(langId, tree, text, position) {
             return ['script', 'subagent', 'tool'].map(kw);
         }
         if (/\bon\s+\S*$/.test(before)) {
-            return ['event', 'intent', 'offtopic', 'fallback', 'complete', 'failed'].map(kw);
+            return ['event', 'intent', 'offtopic', 'failure', 'success'].map(kw);
         }
 
         // Context-aware: top-level vs. inside a block
@@ -72,9 +72,9 @@ function provideCompletions(langId, tree, text, position) {
         return (/^\s/.test(line) ? BEHAVIOR_BLOCK_KW : BEHAVIOR_TOP_KW).map(kw);
     }
 
-    if (langId === 'agent') {
+    if (langId === 'description') {
         if (!/^\s/.test(line)) {
-            return AGENT_TOP_KW.map(kw);
+            return DESCRIPTION_TOP_KW.map(kw);
         }
 
         // Inside a strict block → suggest declared types

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 === 'agent') {
+        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',
@@ -26,7 +29,7 @@ const STRICT_BLOCK_TYPES = {
     capabilities_block: 'capabilities',
 };
 
-function diagnoseAgent(tree, text) {
+function diagnoseDescription(tree, text) {
     const diagnostics = [];
 
     // ── Strict block validation ───────────────────────────────────────────────
@@ -44,7 +47,7 @@ function diagnoseAgent(tree, text) {
                     range: nodeToRange(errorNode),
                     message: `Syntax error in '${blockName}' block. Expected: Type or Type "Description", or compact: Type1, Type2.`,
                     severity: DiagnosticSeverity.Error,
-                    source: 'agent-dsl',
+                    source: 'description-dsl',
                 });
             }
 
@@ -59,7 +62,7 @@ function diagnoseAgent(tree, text) {
                             range: nodeToRange(idNode),
                             message: `Type '${typeName}' is not declared in this file (assuming native or external).`,
                             severity: DiagnosticSeverity.Warning,
-                            source: 'agent-dsl',
+                            source: 'description-dsl',
                         });
                     }
                 }
@@ -70,17 +73,87 @@ function diagnoseAgent(tree, text) {
     return diagnostics;
 }
 
-function diagnoseFlow(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;
@@ -100,18 +173,6 @@ function diagnoseFlow(tree) {
     for (const n of nodesOfType(tree, 'transition_stmt')) {
         checkTransitionTarget(n.childForFieldName('state'));
     }
-    for (const n of nodesOfType(tree, 'intent_trigger')) {
-        // inline form: on intent "..." transition to <state>
-        checkTransitionTarget(n.childForFieldName('state'));
-    }
-    for (const n of nodesOfType(tree, 'fallback_stmt')) {
-        // inline form: on fallback transition to <state>
-        checkTransitionTarget(n.childForFieldName('state'));
-    }
-    for (const n of nodesOfType(tree, 'offtopic_stmt')) {
-        // inline form: on offtopic transition to <state>
-        checkTransitionTarget(n.childForFieldName('state'));
-    }
 
     // ── Rule 2: Dead-end interact (now redundant but kept for safety) ────────────
     // With the new grammar, oriented_state_body requires repeat1(handlers),
@@ -125,14 +186,13 @@ function diagnoseFlow(tree) {
 
         // With new grammar: oriented_state_body always has handlers after interact (repeat1)
         // So this check should never trigger, but kept for robustness
-        const hasHandlers = ancestor.descendantsOfType('intent_trigger').length +
-                           ancestor.descendantsOfType('fallback_stmt').length +
-                           ancestor.descendantsOfType('offtopic_stmt').length > 0;
+        const hasHandlers = ancestor.descendantsOfType('intent_handler').length +
+                           ancestor.descendantsOfType('offtopic_handler').length > 0;
 
         if (!hasHandlers) {
             diagnostics.push({
                 range: nodeToRange(interactNode),
-                message: "This state calls interact but has no handlers (on intent/fallback/offtopic). This will trap the agent.",
+                message: "This state calls interact but has no handlers (on intent/offtopic). This will trap the agent.",
                 severity: DiagnosticSeverity.Warning,
                 source: 'behavior-dsl',
             });
@@ -142,10 +202,10 @@ function diagnoseFlow(tree) {
     return diagnostics;
 }
 
-function diagnose(langId, tree, text) {
+function diagnose(langId, tree, text, uri) {
     if (!tree) return [];
-    if (langId === 'agent') return diagnoseAgent(tree, text);
-    if (langId === 'behavior')  return diagnoseFlow(tree);
+    if (langId === 'description') return diagnoseDescription(tree, text);
+    if (langId === 'behavior')  return diagnoseBehavior(tree, uri);
     return [];
 }
 

package/features/formatting.js

@@ -16,7 +16,7 @@
 
 'use strict';
 
-const BLOCK_HEADERS = /^(on\s+(intent|offtopic|fallback|complete|failed)|if|else|after|parallel)\b/;
+const BLOCK_HEADERS = /^(on\s+(intent|offtopic|failure|success)|if|else|after|parallel)\b/;
 const TOP_LEVEL_LINE = /^(state|merge)\s|^on\s+event\b/;
 
 function formatBehavior(text) {
@@ -39,7 +39,12 @@ function formatBehavior(text) {
             if (BLOCK_HEADERS.test(trimmed)) mode = 'NESTED_BODY';
             expectedIndent = 2;
         } else {
-            expectedIndent = BLOCK_HEADERS.test(trimmed) ? 2 : 4;
+            if (/^end\b/.test(trimmed)) {
+                mode = 'STATE_BODY';
+                expectedIndent = 2;
+            } else {
+                expectedIndent = BLOCK_HEADERS.test(trimmed) ? 2 : 4;
+            }
         }
 
         const actualIndent = raw.length - raw.trimStart().length;
@@ -53,7 +58,7 @@ function formatBehavior(text) {
     return edits;
 }
 
-function formatAgent(text) {
+function formatDescription(text) {
     const edits = [];
     const lines = text.split('\n');
     for (let i = 0; i < lines.length; i++) {
@@ -73,7 +78,7 @@ function formatAgent(text) {
 
 function format(langId, text) {
     if (langId === 'behavior') return formatBehavior(text);
-    if (langId === 'agent') return formatAgent(text);
+    if (langId === 'description') return formatDescription(text);
     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/hover.js

@@ -18,7 +18,7 @@
 
 const { MarkupKind } = require('vscode-languageserver');
 
-const AGENT_DOCS = {
+const DESCRIPTION_DOCS = {
     'agent':        '**`agent name`**\n\nDeclares a new agent. The central node of the manifest.',
     'domain':       '**`domain url`**\n\nDeclares the canonical domain for this agent, establishing cryptographic identity and ownership.',
     'license':      '**`license type`**\n\nDeclares the license under which this agent is distributed (e.g., MIT, Copyright).',
@@ -32,30 +32,32 @@ const AGENT_DOCS = {
     'output':       '**`output Type`**\n\nThe data type this agent returns.',
     'type':         '**`type name`**\n\nDeclares a custom type to anchor custom typing to Wikidata or Schema.org.',
     'concept':      '**`concept url`**\n\nThe Wikidata or Schema.org concept URL this type maps to.',
-    'schema':       '**`schema file.json`**\n\nA JSON schema file for this type.',
 };
 
 const BEHAVIOR_DOCS = {
     'merge':       '**`merge "file.behavior"`**\n\nIncludes another `.behavior` file. Must appear before any `state` or `on event` declarations (preamble-only, eager loading).',
     'state':       '**`state name`**\n\nDeclares a named state. States contain the logic that runs while the agent is in that state.',
-    'on':          '**`on event|intent|offtopic|fallback|complete|failed`**\n\nBinds a handler to a trigger. Top-level: `on event`. Inside a state: `on intent`, `on offtopic`, `on fallback`. After parallel: `on complete`, `on failed`.',
-    'run':         '**`run script|subagent|tool "target"`**\n\nExecutes a script, subagent, or tool. Accepts optional modifiers: `silent`, `in background`, `each collection`.',
+    'on':          '**`on event|intent|offtopic|failure|success`**\n\nBinds a handler to a trigger. Top-level: `on event`. Inside a state: `on intent`, `on offtopic`. After `run`/`apply`/`remove`: `on failure`. Inside `parallel`: `on success` (optional), `on failure` (required).',
+    'run':         '**`run script|subagent|tool "target" ["parameters"]`**\n\nExecutes a script, subagent, or tool. Optionally followed by `on failure` to handle errors.',
     'guide':       '**`guide "text"`**\n\nInjects a system-level instruction into the conversation context, shaping the agent\'s persona or approach without being visible as a reply.',
-    'teach':       '**`teach "text"`**\n\nAdds a fact or constraint to the agent\'s working knowledge for the duration of this state.',
+    'teach':       '**`teach "file"`**\n\nLoads a file into the agent\'s working knowledge for the duration of this state.',
     'goal':        '**`goal "text"`**\n\nSets the agent\'s objective for this state, used by the runtime for planning and alignment checks.',
-    'interact':    '**`interact [requiring "text"]`**\n\nPauses execution and waits for user input. Optionally enforces a requirement before continuing.',
+    'interact':    '**`interact`**\n\nPauses execution and waits for user input.',
     'set':         '**`set domain.var = value`**\n\nAssigns a value to a memory variable. Domains: `context`, `session`, `worksession`, `user`.',
     'context':     '**`context`** memory domain — scoped to the current agent run.',
     'session':     '**`session`** memory domain — persists for the user\'s current session.',
     'worksession': '**`worksession`** memory domain — persists across a task-oriented work session (isolated per task).',
     'user':        '**`user`** memory domain — persists across sessions for a given user.',
     'transition':  '**`transition to state`**\n\nTransitions immediately to the named state.',
-    'if':          '**`if condition`**\n\nConditional execution. Condition can use `==`, `!=`, `>`, `<`, `>=`, `<=`, `and`, `or`.',
-    'else':        '**`else`**\n\nAlternative branch of an `if` statement.',
+    'if':          '**`if condition`**\n\nConditional execution. Condition can use `==`, `!=`, `>`, `<`, `>=`, `<=`, `and`, `or`. Close the block with `end`.',
+    'else':        '**`else`**\n\nAlternative branch of an `if` statement. Close the block with `end`.',
+    'end':         '**`end`**\n\nCloses an `if`/`else` block.',
     'after':       '**`after N prompts`**\n\n[Experimental] Executes a block after N user prompts have occurred in this state.',
-    'parallel':    '**`parallel`**\n\n[Experimental] Runs a block of `run` statements concurrently. Follow with `on complete` and `on failed` handlers.',
-    'apply':       '**`apply css|html|video "text"`**\n\nApplies a UI manipulation to a CSS selector, HTML element, or video element.',
-    'remove':      '**`remove css|html|video "text"`**\n\nRemoves a UI element by selector or reference.',
+    'parallel':    '**`parallel`**\n\n[Experimental] Runs a block of `run` statements concurrently. Follow with optional `on success` and required `on failure` handlers.',
+    'apply':       '**`apply css "selector"`**\n\nApplies a UI manipulation to a CSS selector. Optionally followed by `on failure`.',
+    'remove':      '**`remove css "selector"`**\n\nRemoves a UI element by CSS selector. Optionally followed by `on failure`.',
+    'failure':     '**`on failure`**\n\nError handler block executed when a `run`, `apply`, `remove`, or `parallel` statement fails.',
+    'success':     '**`on success`**\n\nOptional success handler block inside a `parallel` statement.',
 };
 
 function provideHover(langId, text, position) {
@@ -70,7 +72,7 @@ function provideHover(langId, text, position) {
     const word = line.slice(start, end);
     if (!word) return null;
 
-    const docs = langId === 'agent' ? AGENT_DOCS : BEHAVIOR_DOCS;
+    const docs = langId === 'description' ? DESCRIPTION_DOCS : BEHAVIOR_DOCS;
     const doc = docs[word];
     if (!doc) return null;
 

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,27 +51,41 @@ function provideDocumentLinks(langId, tree, docUri) {
         });
     }
 
-    if (langId === 'agent') {
+    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, 'schema_prop')) {
+        for (const node of nodesOfType(tree, 'persona_block')) {
             const fileNode = node.childForFieldName('file');
-            if (fileNode) addLink(fileNode, fileNode.text);
+            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('run_type');
+            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/features/references.js

@@ -41,12 +41,7 @@ function provideReferences(langId, tree, text, uri, position) {
             const stateNode = n.childForFieldName('state');
             if (stateNode?.text === word) add(stateNode);
         }
-        // Inline intent handlers: on intent "..." next <state>
-        for (const n of nodesOfType(tree, 'intent_trigger')) {
-            const stateNode = n.childForFieldName('state');
-            if (stateNode?.text === word) add(stateNode);
-        }
-    } else if (langId === 'agent') {
+    } else if (langId === 'description') {
         // Declaration
         for (const n of nodesOfType(tree, 'type_decl')) {
             const nameNode = n.childForFieldName('name');

package/features/rename.js

@@ -41,12 +41,7 @@ function provideRenameEdits(langId, tree, text, uri, position, newName) {
             const stateNode = n.childForFieldName('state');
             if (stateNode?.text === oldName) addEdit(stateNode);
         }
-        // Rename inline intent handler targets
-        for (const n of nodesOfType(tree, 'intent_trigger')) {
-            const stateNode = n.childForFieldName('state');
-            if (stateNode?.text === oldName) addEdit(stateNode);
-        }
-    } else if (langId === 'agent') {
+    } else if (langId === 'description') {
         // Rename type declarations
         for (const n of nodesOfType(tree, 'type_decl')) {
             const nameNode = n.childForFieldName('name');

package/features/symbols.js

@@ -49,7 +49,7 @@ function provideDocumentSymbols(langId, tree) {
         }
     }
 
-    if (langId === 'agent') {
+    if (langId === 'description') {
         for (const node of nodesOfType(tree, 'agent_decl')) {
             const nameNode = node.childForFieldName('name');
             if (!nameNode) continue;

package/package.json

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

package/parser.js

@@ -21,17 +21,17 @@ const { Parser, Language } = require('web-tree-sitter');
 const grammar = require('@dot-agent/tree-sitter');
 
 // path.resolve ensures absolute paths survive vsix packaging and cwd changes
-const AGENT_WASM = path.resolve(grammar.agentWasmPath);
+const DESCRIPTION_WASM = path.resolve(grammar.agentWasmPath);
 const BEHAVIOR_WASM  = path.resolve(grammar.behaviorWasmPath);
 
-let agentParser, behaviorParser;
+let descriptionParser, behaviorParser;
 
 async function initParsers() {
     await Parser.init();
-    const Agent = await Language.load(AGENT_WASM);
+    const DescriptionLang = await Language.load(DESCRIPTION_WASM);
     const Behavior  = await Language.load(BEHAVIOR_WASM);
-    agentParser = new Parser();
-    agentParser.setLanguage(Agent);
+    descriptionParser = new Parser();
+    descriptionParser.setLanguage(DescriptionLang);
     behaviorParser = new Parser();
     behaviorParser.setLanguage(Behavior);
 }
@@ -42,7 +42,7 @@ const cache = new Map();
 function parse(uri, langId, text, version) {
     const prev = cache.get(uri);
     if (prev?.version === version) return prev.tree;
-    const parser = langId === 'behavior' ? behaviorParser : agentParser;
+    const parser = langId === 'behavior' ? behaviorParser : descriptionParser;
     if (!parser) return null;
     const tree = parser.parse(text, prev?.tree);   // incremental reuse when possible
     cache.set(uri, { version, tree });
@@ -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);
@@ -71,9 +72,9 @@ function getTree(doc) {
 
 function validate(doc) {
     const langId = doc.languageId;
-    if (langId !== 'agent' && langId !== 'behavior') return;
+    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);