@telorun/ide-support 0.6.0 → 0.7.0

package/dist/hover/build-hover.js

@@ -0,0 +1,125 @@
+import { parseToAst, } from "@telorun/analyzer";
+import { navigateSchema } from "../completions/detect-context.js";
+import { resolveNodeAtPosition, scalarString, } from "../completions/resolve-node.js";
+import { CAPABILITY_DOCS } from "../completions/valid-capabilities.js";
+/** Docs for the structural keys shared by every module doc, so hover is useful
+ *  even at the root, where there is no user-authored schema to navigate. */
+const STRUCTURAL_KEY_DOCS = {
+    kind: "The resource kind — `Alias.Name` for an imported kind, or a `Telo.*` root kind.",
+    metadata: "Resource identity: `name` (kebab-case, dot-free) and optional `namespace`.",
+    imports: "Dependency map: PascalCase alias → `namespace/name@version` source string or object.",
+    targets: "Boot sequence run after init — references to `Runnable`/`Service` resources or inline invoke steps.",
+    variables: "Typed inputs bound from host env vars (`env:` + JSON-Schema `type:`).",
+    secrets: "Secret inputs bound from host env vars (`env:` + `type:`).",
+    ports: "Inbound ports the app listens on, each bound to a host env var (Application only).",
+    exports: "What importers may reference: `kinds` (kind gate) and `resources` (instance singletons).",
+    include: "Partial files loaded into this module scope (paths / globs).",
+    capability: "The lifecycle role of the kind this definition registers.",
+    schema: "JSON Schema for the kind's config fields, with `x-telo-*` annotations.",
+    extends: "Alias-form kind this definition specializes (abstract contract or concrete parent).",
+    base: "Construction mapping (`super(...)`) over `self` for a concrete-`extends` definition.",
+    controllers: "Controller locator (`pkg:npm`) implementing this kind.",
+};
+/** The kind value of the map that directly encloses `keyName` in the value slot. */
+function typeName(t) {
+    if (typeof t === "string")
+        return t;
+    if (t && typeof t === "object" && typeof t.title === "string")
+        return t.title;
+    return undefined;
+}
+function kindHover(kind, def) {
+    if (!def)
+        return `\`${kind}\``;
+    const lines = [`### ${kind}`];
+    const role = def.capability ? `\`${def.capability}\`` : "resource";
+    const module = def.metadata?.module ? ` · module \`${def.metadata.module}\`` : "";
+    lines.push(`${role}${module}`);
+    const schema = def.schema;
+    const desc = schema?.description ?? schema?.title;
+    if (typeof desc === "string" && desc)
+        lines.push("", desc);
+    if (def.extends)
+        lines.push("", `Extends \`${def.extends}\``);
+    const input = typeName(def.inputType);
+    const output = typeName(def.outputType);
+    if (input)
+        lines.push(`Input \`${input}\``);
+    if (output)
+        lines.push(`Output \`${output}\``);
+    return lines.join("\n");
+}
+function fieldHover(keyName, field) {
+    const lines = [];
+    const type = Array.isArray(field.type) ? field.type.join(" | ") : field.type;
+    const head = type ? `**${keyName}**: \`${type}\`` : `**${keyName}**`;
+    lines.push(head);
+    if (typeof field.description === "string" && field.description) {
+        lines.push("", field.description);
+    }
+    const ref = field["x-telo-ref"];
+    if (typeof ref === "string")
+        lines.push("", `Reference → \`${ref}\``);
+    if (Array.isArray(field.enum) && field.enum.length > 0) {
+        lines.push("", `Allowed: ${field.enum.map((v) => `\`${v}\``).join(", ")}`);
+    }
+    if (field.default !== undefined)
+        lines.push(`Default: \`${JSON.stringify(field.default)}\``);
+    return lines.length > 0 ? lines.join("\n") : `**${keyName}**`;
+}
+/** Field schema at the nearest enclosing resource, or undefined when the scope
+ *  can't be resolved (no kind-bearing ancestor, or the path doesn't navigate). */
+function fieldSchemaFor(resourceKind, relativePath, registry) {
+    if (!resourceKind || !registry)
+        return undefined;
+    const def = registry.resolveDefinition(resourceKind);
+    if (!def?.schema)
+        return undefined;
+    return navigateSchema(def.schema, relativePath);
+}
+export function buildHover(text, line, character, registry, docs) {
+    const astDocs = docs ?? parseToAst(text);
+    const resolved = resolveNodeAtPosition(text, astDocs, line, character);
+    if (!resolved)
+        return undefined;
+    if (resolved.slot === "value")
+        return hoverForValue(resolved, registry);
+    return hoverForKey(resolved, registry);
+}
+function hoverForValue(resolved, registry) {
+    const key = resolved.path[resolved.path.length - 1];
+    const value = scalarString(resolved.node);
+    const range = resolved.replaceRange;
+    if (key === "kind" && value) {
+        return { contents: kindHover(value, registry?.resolveDefinition(value)), range };
+    }
+    if (key === "capability" && resolved.docKind === "Telo.Definition" && value) {
+        const doc = CAPABILITY_DOCS[value];
+        return doc ? { contents: `**${value}**\n\n${doc}`, range } : undefined;
+    }
+    // Field value: describe the field via the enclosing resource's schema. Works
+    // when the value sits directly under a kind-bearing map (`siblingKind`); the
+    // field path relative to that map is just the key.
+    if (key) {
+        const field = fieldSchemaFor(resolved.siblingKind, [key], registry);
+        if (field)
+            return { contents: fieldHover(key, field), range };
+    }
+    return undefined;
+}
+function hoverForKey(resolved, registry) {
+    const keyName = scalarString(resolved.node);
+    if (!keyName)
+        return undefined;
+    const range = resolved.replaceRange;
+    const resourceKind = resolved.resourceKind ?? resolved.docKind;
+    const relativePath = [...resolved.path.slice(resolved.resourceDepth ?? 0), keyName];
+    const field = fieldSchemaFor(resourceKind, relativePath, registry);
+    if (field)
+        return { contents: fieldHover(keyName, field), range };
+    const structural = STRUCTURAL_KEY_DOCS[keyName];
+    if (structural && relativePath.length === 1) {
+        return { contents: `**${keyName}**\n\n${structural}`, range };
+    }
+    return undefined;
+}

package/dist/hover/index.d.ts

@@ -0,0 +1,2 @@
+export { buildHover } from "./build-hover.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hover/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hover/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/hover/index.js

@@ -0,0 +1 @@
+export { buildHover } from "./build-hover.js";

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export * from "./types.js";
 export * from "./completions/index.js";
 export * from "./diagnostics/index.js";
+export * from "./hover/index.js";
+export * from "./semantic-tokens/index.js";
+export * from "./definition/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,3 +1,6 @@
 export * from "./types.js";
 export * from "./completions/index.js";
 export * from "./diagnostics/index.js";
+export * from "./hover/index.js";
+export * from "./semantic-tokens/index.js";
+export * from "./definition/index.js";

package/dist/semantic-tokens/build-semantic-tokens.d.ts

@@ -0,0 +1,12 @@
+import { type AnalysisRegistry, type AstDocument } from "@telorun/analyzer";
+import type { SemanticToken } from "../types.js";
+/** Registry-aware semantic tokens: a `kind:` value that resolves to a known
+ *  definition is a `type`; a `capability:` value is an `interface`; a `!ref`
+ *  target is a `variable`. Everything else (structure, CEL, tags) is left to the
+ *  TextMate grammar. Ref targets are colored here rather than in the grammar
+ *  because a `!ref` after a `key:` is tokenized by the bundled YAML grammar
+ *  before a Telo pattern can claim it — the AST sees it unambiguously. An
+ *  unresolved kind gets no token, so a typo stays uncolored — a quiet signal
+ *  that pairs with the analyzer's `UNDEFINED_KIND` diagnostic. */
+export declare function buildSemanticTokens(text: string, registry: AnalysisRegistry | undefined, docs?: AstDocument[]): SemanticToken[];
+//# sourceMappingURL=build-semantic-tokens.d.ts.map

package/dist/semantic-tokens/build-semantic-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-semantic-tokens.d.ts","sourceRoot":"","sources":["../../src/semantic-tokens/build-semantic-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD;;;;;;;kEAOkE;AAClE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,IAAI,CAAC,EAAE,WAAW,EAAE,GACnB,aAAa,EAAE,CAqCjB"}

package/dist/semantic-tokens/build-semantic-tokens.js

@@ -0,0 +1,55 @@
+import { buildLineOffsets, offsetToPosition, parseToAst, } from "@telorun/analyzer";
+import { scalarString } from "../completions/resolve-node.js";
+import { CAPABILITY_VALUES } from "../completions/valid-capabilities.js";
+const CAPABILITIES = new Set(CAPABILITY_VALUES);
+/** Registry-aware semantic tokens: a `kind:` value that resolves to a known
+ *  definition is a `type`; a `capability:` value is an `interface`; a `!ref`
+ *  target is a `variable`. Everything else (structure, CEL, tags) is left to the
+ *  TextMate grammar. Ref targets are colored here rather than in the grammar
+ *  because a `!ref` after a `key:` is tokenized by the bundled YAML grammar
+ *  before a Telo pattern can claim it — the AST sees it unambiguously. An
+ *  unresolved kind gets no token, so a typo stays uncolored — a quiet signal
+ *  that pairs with the analyzer's `UNDEFINED_KIND` diagnostic. */
+export function buildSemanticTokens(text, registry, docs) {
+    const astDocs = docs ?? parseToAst(text);
+    const lineOffsets = buildLineOffsets(text);
+    const tokens = [];
+    const emit = (node, type) => {
+        if (!node)
+            return;
+        const start = offsetToPosition(node.range[0], lineOffsets);
+        const end = offsetToPosition(node.range[1], lineOffsets);
+        // Kind / capability values never span lines; a clamped single-line token.
+        if (start.line !== end.line)
+            return;
+        tokens.push({ line: start.line, character: start.character, length: end.character - start.character, type });
+    };
+    const walk = (node) => {
+        if (node.kind === "map") {
+            for (const pair of node.entries) {
+                const key = scalarString(pair.key);
+                const value = scalarString(pair.value);
+                if (key === "kind" && value && registry?.resolveDefinition(value)) {
+                    emit(pair.value, "type");
+                }
+                else if (key === "capability" && value && CAPABILITIES.has(value)) {
+                    emit(pair.value, "interface");
+                }
+                if (pair.value)
+                    walk(pair.value);
+            }
+        }
+        else if (node.kind === "seq") {
+            for (const item of node.items)
+                walk(item);
+        }
+        else if (node.kind === "scalar" && node.tag === "!ref") {
+            emit(node, "variable");
+        }
+    };
+    for (const doc of astDocs) {
+        if (doc.root)
+            walk(doc.root);
+    }
+    return tokens;
+}

package/dist/semantic-tokens/index.d.ts

@@ -0,0 +1,2 @@
+export { buildSemanticTokens } from "./build-semantic-tokens.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/semantic-tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semantic-tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/semantic-tokens/index.js

@@ -0,0 +1 @@
+export { buildSemanticTokens } from "./build-semantic-tokens.js";

package/dist/types.d.ts

@@ -1,7 +1,12 @@
 export { AnalysisRegistry, DiagnosticSeverity } from "@telorun/analyzer";
 export type { Position, Range, AnalysisDiagnostic, PositionIndex, } from "@telorun/analyzer";
-import type { AnalysisRegistry, DiagnosticSeverity, PositionIndex, Range } from "@telorun/analyzer";
+import type { AnalysisRegistry, DiagnosticSeverity, Position, PositionIndex, Range } from "@telorun/analyzer";
 export type CompletionKind = "class" | "enumMember" | "property" | "folder" | "module" | "value";
+/** A source span the host replaces wholesale when a completion is accepted. */
+export interface ReplaceRange {
+    start: Position;
+    end: Position;
+}
 export interface CompletionResult {
     label: string;
     kind: CompletionKind;
@@ -12,11 +17,45 @@ export interface CompletionResult {
     preselect?: boolean;
     sortText?: string;
     filterText?: string;
-    /** When set, the host should replace text from this 0-based column on the
-     *  cursor's line up to the cursor. Required when the completion value
-     *  contains non-word characters (`/`, `@`, `.`) that the host's default
-     *  word boundary would not include in the replaced range. */
-    replaceFromColumn?: number;
+    /** When set, the host replaces this whole source range with the accepted
+     *  value — the full span of the existing node, not just the prefix up to the
+     *  cursor. This overwrites any suffix after the cursor (`Sql.Co|nnection` +
+     *  `Sql.Connection` → no leftover `nnection`) and cleanly replaces values
+     *  containing non-word characters (`/`, `@`, `.`). A zero-width range is a
+     *  pure insert. */
+    replaceRange?: ReplaceRange;
+}
+/** Rendered hover for the symbol under the cursor. `contents` is GitHub-flavored
+ *  markdown; `range` (when present) is the source span the host underlines. */
+export interface HoverResult {
+    contents: string;
+    range?: ReplaceRange;
+}
+/** Semantic token type names emitted by `buildSemanticTokens`. Kept to the
+ *  standard VS Code / LSP set so hosts register them against a stock legend and
+ *  every theme colors them without extra configuration. `type` marks a resolved
+ *  resource kind; `interface` marks a capability value; `variable` marks a
+ *  `!ref` target. */
+export type SemanticTokenType = "type" | "interface" | "variable";
+/** The legend a host registers before mapping `buildSemanticTokens` output. The
+ *  numeric token-type of each `SemanticToken` is its index in this array. */
+export declare const SEMANTIC_TOKEN_LEGEND: readonly SemanticTokenType[];
+/** One absolute-positioned semantic token. Every Telo semantic token is
+ *  single-line (kinds and capabilities never wrap), so a `{line, char, length}`
+ *  triple is sufficient; the host encodes it into its own builder. */
+export interface SemanticToken {
+    line: number;
+    character: number;
+    length: number;
+    type: SemanticTokenType;
+}
+/** Where a `!ref` target is defined — for go-to-definition. `uri` is the
+ *  target file's canonical source (absolute path for local files, an http/oci
+ *  URL for a registry import); `range` spans the target resource's
+ *  `metadata.name` (falling back to its first line). */
+export interface DefinitionResult {
+    uri: string;
+    range: Range;
 }
 /** A candidate module ref surfaced by the hub's `/refs` lexical autocomplete.
  *  Identity is the location ref, never `namespace/name` — an OCI module has no

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGzE,YAAY,EACV,QAAQ,EACR,KAAK,EACL,kBAAkB,EAClB,aAAa,GACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAEpG,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEjG,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;iEAG6D;IAC7D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;wDAGwD;AACxD,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;uCAMuC;AACvC,MAAM,WAAW,qBAAqB;IACpC;;2DAEuD;IACvD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD;kEAC8D;IAC9D,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C;;;oFAGgF;IAChF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7C;;0CAEsC;IACtC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE;;;0EAGsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGzE,YAAY,EACV,QAAQ,EACR,KAAK,EACL,kBAAkB,EAClB,aAAa,GACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,EACR,aAAa,EACb,KAAK,EACN,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEjG,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;uBAKmB;IACnB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED;+EAC+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;qBAIqB;AACrB,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,CAAC;AAElE;6EAC6E;AAC7E,eAAO,MAAM,qBAAqB,EAAE,SAAS,iBAAiB,EAAsC,CAAC;AAErG;;sEAEsE;AACtE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED;;;wDAGwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;CACd;AAED;;;wDAGwD;AACxD,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;uCAMuC;AACvC,MAAM,WAAW,qBAAqB;IACpC;;2DAEuD;IACvD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD;kEAC8D;IAC9D,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C;;;oFAGgF;IAChF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7C;;0CAEsC;IACtC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE;;;0EAGsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/types.js

@@ -1,3 +1,6 @@
 // Runtime values (classes, enums) — consumers who need `new AnalysisRegistry()`
 // or `DiagnosticSeverity.Error` import from here.
 export { AnalysisRegistry, DiagnosticSeverity } from "@telorun/analyzer";
+/** The legend a host registers before mapping `buildSemanticTokens` output. The
+ *  numeric token-type of each `SemanticToken` is its index in this array. */
+export const SEMANTIC_TOKEN_LEGEND = ["type", "interface", "variable"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/ide-support",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Editor-host-agnostic IDE support (completions, diagnostic normalization) for Telo manifests.",
   "keywords": [
     "telo",
@@ -36,7 +36,7 @@
     "src/**"
   ],
   "dependencies": {
-    "@telorun/analyzer": "0.40.0"
+    "@telorun/analyzer": "0.41.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/completions/build.ts

@@ -1,5 +1,6 @@
-import type { AnalysisRegistry } from "@telorun/analyzer";
+import { parseToAst, type AnalysisRegistry, type AstDocument, type AstMap } from "@telorun/analyzer";
 import type { CompletionResult, IdeEnvironmentAdapter } from "../types.js";
+import type { ReplaceRange } from "./detect-context.js";
 import { detectContext, lookupRefConstraint } from "./detect-context.js";
 import { importSourceCompletions } from "./import-source.js";
 import { propKeyCompletions } from "./prop-keys.js";
@@ -10,56 +11,29 @@ interface ResourceRecord {
   name: string;
 }
 
-/** Roughly extract `(kind, metadata.name)` pairs from a multi-doc YAML text.
- *  This is intentionally lightweight: it scans for top-level `kind:` and the
- *  first `name:` under a `metadata:` block per `---`-separated section, with
- *  no full YAML parse. The output is consumed only for completion ranking,
- *  so misses on edge-case manifests are acceptable; the analyzer remains
- *  the source of truth for validation. */
-function extractInFileResources(text: string): ResourceRecord[] {
+/** Read the top-level `kind` and `metadata.name` scalar of each document from
+ *  the AST. Consumed only for ref-name completion ranking, so a doc missing
+ *  either is simply skipped; the analyzer remains the source of truth. */
+function extractInFileResources(docs: AstDocument[]): ResourceRecord[] {
   const out: ResourceRecord[] = [];
-  const lines = text.split("\n");
-  let currentKind: string | undefined;
-  let currentName: string | undefined;
-  let inMetadata = false;
+  const scalar = (node: { kind: string; value?: unknown } | undefined): string | undefined =>
+    node?.kind === "scalar" && typeof node.value === "string" ? node.value : undefined;
 
-  const flush = () => {
-    if (currentKind && currentName) {
-      out.push({ kind: currentKind, name: currentName });
-    }
-    currentKind = undefined;
-    currentName = undefined;
-    inMetadata = false;
-  };
-
-  for (const line of lines) {
-    if (line.trimEnd() === "---") {
-      flush();
-      continue;
-    }
-    const kindMatch = line.match(/^kind:\s*(\S+)/);
-    if (kindMatch) {
-      currentKind = kindMatch[1];
-      continue;
-    }
-    if (/^metadata:\s*$/.test(line)) {
-      inMetadata = true;
-      continue;
-    }
-    if (inMetadata) {
-      // Lines inside metadata are indented. Pick the first `name:` we see.
-      const nameMatch = line.match(/^\s+name:\s*(\S+)/);
-      if (nameMatch && !currentName) {
-        currentName = nameMatch[1];
-      }
-      // Leaving the metadata block — any line that is not indented marks
-      // the end of the block.
-      if (line.length > 0 && !/^\s/.test(line)) {
-        inMetadata = false;
+  for (const doc of docs) {
+    if (doc.root?.kind !== "map") continue;
+    let kind: string | undefined;
+    let name: string | undefined;
+    for (const pair of doc.root.entries) {
+      const key = scalar(pair.key);
+      if (key === "kind") kind = scalar(pair.value);
+      else if (key === "metadata" && pair.value?.kind === "map") {
+        const meta = pair.value as AstMap;
+        const nameEntry = meta.entries.find((e) => scalar(e.key) === "name");
+        name = scalar(nameEntry?.value);
       }
     }
+    if (kind && name) out.push({ kind, name });
   }
-  flush();
   return out;
 }
 
@@ -71,13 +45,13 @@ function extractInFileResources(text: string): ResourceRecord[] {
  *  user still sees something rather than nothing when the registry
  *  doesn't recognize the kind yet. */
 function refNameCompletions(
-  text: string,
+  docs: AstDocument[],
   refKind: string | undefined,
   refConstraint: string | undefined,
   registry: AnalysisRegistry | undefined,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
 ): CompletionResult[] {
-  const resources = extractInFileResources(text);
+  const resources = extractInFileResources(docs);
   let acceptable: Set<string> | undefined;
 
   if (refKind) {
@@ -97,10 +71,9 @@ function refNameCompletions(
       label: r.name,
       kind: "value",
       detail: r.kind,
-      // Anchor the replace range to the value's start column so names with
-      // `.`, `-`, or `/` (legal in resource names) replace the whole typed
-      // prefix instead of the trailing word VS Code would pick by default.
-      replaceFromColumn: valueStartColumn,
+      // Replace the whole existing value so names with `.`, `-`, or `/` (legal
+      // in resource names) overwrite cleanly instead of the trailing word.
+      replaceRange,
     });
   }
   return out;
@@ -129,7 +102,7 @@ function kindCompletions(
   registry: AnalysisRegistry | undefined,
   docKind: string | undefined,
   yamlPath: string[] | undefined,
-  valueStartColumn: number | undefined,
+  replaceRange: ReplaceRange,
 ): CompletionResult[] {
   let kinds: Iterable<string>;
   if (registry && docKind && yamlPath && yamlPath.length > 0) {
@@ -145,14 +118,10 @@ function kindCompletions(
   for (const kind of kinds) {
     if (seen.has(kind)) continue;
     seen.add(kind);
-    const item: CompletionResult = { label: kind, kind: "class", detail: "Telo resource kind" };
-    // Anchor the replace range to the value's start column so kinds with `.`
-    // (e.g. `Sql.Connection`) cleanly overwrite the existing prefix. Without
-    // this, VS Code's default word boundary stops at the last `.` and a pick
-    // of `Sql.Connection` while the buffer reads `Sql.Co|` becomes
-    // `Sql.Sql.Connection`.
-    if (valueStartColumn !== undefined) item.replaceFromColumn = valueStartColumn;
-    results.push(item);
+    // Replace the whole existing kind scalar so a pick of `Sql.Connection`
+    // over `Sql.Co|nnection` leaves no `nnection` suffix and no `Sql.` prefix
+    // duplication (VS Code's default word range stops at the last `.`).
+    results.push({ label: kind, kind: "class", detail: "Telo resource kind", replaceRange });
   }
   return results;
 }
@@ -171,11 +140,16 @@ export async function buildCompletions(
   character: number,
   registry: AnalysisRegistry | undefined,
   adapter?: IdeEnvironmentAdapter,
+  docs?: AstDocument[],
 ): Promise<CompletionResult[]> {
-  const ctx = detectContext(text, line, character);
+  // Reuse the host's already-parsed AST when it matches the current buffer;
+  // otherwise parse once here (Part 1 stands alone). Both `detectContext` and
+  // ref-name in-file resource extraction share this single parse.
+  const astDocs = docs ?? parseToAst(text);
+  const ctx = detectContext(text, line, character, astDocs);
   if (!ctx) return [];
   if (ctx.type === "kind") {
-    return kindCompletions(registry, ctx.docKind, ctx.yamlPath, ctx.valueStartColumn);
+    return kindCompletions(registry, ctx.docKind, ctx.yamlPath, ctx.replaceRange);
   }
   if (ctx.type === "capability") return capabilityCompletions();
   if (ctx.type === "ref-name") {
@@ -183,17 +157,11 @@ export async function buildCompletions(
     const refConstraint = definition?.schema
       ? lookupRefConstraint(definition.schema as Record<string, any>, ctx.yamlPath)
       : undefined;
-    return refNameCompletions(
-      text,
-      ctx.refKind,
-      refConstraint,
-      registry,
-      ctx.valueStartColumn,
-    );
+    return refNameCompletions(astDocs, ctx.refKind, refConstraint, registry, ctx.replaceRange);
   }
   if (ctx.type === "field-value") {
     if (ctx.field === "import-source") {
-      return importSourceCompletions(ctx.prefix, ctx.valueStartColumn, adapter);
+      return importSourceCompletions(ctx.prefix, ctx.replaceRange, adapter);
     }
     return [];
   }