@telorun/ide-support 0.2.0

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 DiglyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact DiglyAI.

package/README.md

@@ -0,0 +1,238 @@
+---
+description: "Telo: YAML-driven execution engine for declarative backends with micro-kernel architecture and language-agnostic design"
+---
+
+# ⚡ Telo
+
+Runtime for declarative backends.
+
+Telo is an execution engine (Micro-Kernel) that runs logic defined entirely in YAML manifests. Instead of writing imperative backend code, you define your routes, databases, schemas, and AI workflows as atomic, interconnected YAML documents. Telo takes those manifests and runs them.
+
+Built to be language-agnostic and infinitely extensible.
+
+```bash
+# Reconcile your manifest into a running backend
+$ telo ./examples/hello-api.yaml
+
+{"level":30,"time":1771610393008,"pid":1310178,"hostname":"dev","msg":"Server listening at http://127.0.0.1:8844"}
+```
+
+## Why use Telo?
+
+- **Open Standards:** Built on YAML, JSON Schema, and CEL — no proprietary DSL.
+- **Static Analysis:** CEL type checking, reference validation, and IDE diagnostics catch errors before runtime.
+- **Micro-Kernel Architecture:** Telo itself knows nothing about HTTP or SQL. Everything is a module you import, scope, and compose with typed variable and secret contracts.
+- **Language Agnostic:** Available as a Node.js runtime today, with a shared YAML runtime contract that allows for future Rust or Go implementations without changing your manifests.
+
+## What It Does
+
+- **Loads** YAML resources and compiles CEL expressions (`${{ }}`) into an in-memory registry.
+- **Resolves** resource dependencies via a multi-pass init loop, handling ordering automatically.
+- **Indexes** resources by Kind and Name for constant-time lookup.
+- **Dispatches** execution to the controller that owns each Kind.
+
+Manifests also support directives for dynamic generation: `$let`, `$if`, `$for`, `$eval`, and `$include`. See [CEL-YAML Templating](./yaml-cel-templating/README.md) for documentation.
+
+## Example manifest
+
+Here is an example Telo application that defines a simple HTTP API:
+
+```yaml
+kind: Telo.Application
+metadata:
+  name: feedback
+  version: 1.0.0
+  description: |
+    A complete feedback collection REST API — no code, pure YAML.
+    Persists entries to SQLite and serves them over HTTP.
+targets:
+  - Migrations
+  - Server
+---
+kind: Telo.Import
+metadata:
+  name: Http
+source: ../modules/http-server
+---
+kind: Telo.Import
+metadata:
+  name: Sql
+source: ../modules/sql
+---
+# SQLite database — swap driver/host/database for PostgreSQL with zero YAML changes
+kind: Sql.Connection
+metadata:
+  name: Db
+driver: sqlite
+file: ./tmp/feedback.db
+---
+# Migrations: applied automatically before the server starts
+kind: Sql.Migrations
+metadata:
+  name: Migrations
+connection:
+  kind: Sql.Connection
+  name: Db
+---
+kind: Sql.Migration
+metadata:
+  name: Migration_20260413_182154_CreateFeedback
+version: 20260413_182154_CreateFeedback
+sql: |
+  CREATE TABLE IF NOT EXISTS feedback (
+    id        INTEGER PRIMARY KEY AUTOINCREMENT,
+    text      TEXT    NOT NULL,
+    source    TEXT,
+    score     INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+---
+kind: Http.Server
+metadata:
+  name: Server
+baseUrl: http://localhost:8844
+port: 8844
+logger: true
+openapi:
+  info:
+    title: Feedback API
+    version: 1.0.0
+mounts:
+  - path: /v1
+    type: Http.Api.FeedbackRoutes
+---
+kind: Http.Api
+metadata:
+  name: FeedbackRoutes
+routes:
+  # POST /v1/feedback — insert a new entry, score derived from body length heuristic
+  - request:
+      path: /feedback
+      method: POST
+      schema:
+        body:
+          type: object
+          properties:
+            text:
+              type: string
+              minLength: 1
+            source:
+              type: string
+          required: [text]
+    handler:
+      kind: Sql.Exec
+      connection:
+        kind: Sql.Connection
+        name: Db
+    inputs:
+      sql: "INSERT INTO feedback (text, source, score) VALUES (?, ?, ?)"
+      bindings:
+        - "${{ request.body.text }}"
+        - "${{ request.body.source }}"
+        - "${{ size(request.body.text) }}"
+    response:
+      - status: 201
+        headers:
+          Content-Type: application/json
+        body:
+          ok: true
+          message: Feedback received
+
+  # GET /v1/feedback — list all entries, newest first
+  - request:
+      path: /feedback
+      method: GET
+    handler:
+      kind: Sql.Select
+      connection:
+        kind: Sql.Connection
+        name: Db
+      from: feedback
+      columns: [id, text, source, score, created_at]
+      orderBy:
+        - { column: created_at, direction: desc }
+    response:
+      - status: 200
+        headers:
+          Content-Type: application/json
+        body: "${{ result.rows }}"
+
+  # GET /v1/feedback/{id} — fetch a single entry
+  - request:
+      path: /feedback/{id}
+      method: GET
+      schema:
+        params:
+          type: object
+          properties:
+            id:
+              type: integer
+          required: [id]
+    handler:
+      kind: Sql.Select
+      connection:
+        kind: Sql.Connection
+        name: Db
+      from: feedback
+      columns: [id, text, source, score, created_at]
+      where:
+        - { column: id, op: "=", value: "${{ request.params.id }}" }
+    response:
+      - status: 200
+        when: "size(result.rows) > 0"
+        headers:
+          Content-Type: application/json
+        body: "${{ result.rows[0] }}"
+      - status: 404
+        headers:
+          Content-Type: application/json
+        body:
+          ok: false
+          message: Not found
+```
+
+## Status
+
+Telo is under **active development**. The core runtime, module system, and standard library are functional, but the API surface — including YAML shapes — may change without notice. Not yet recommended for production use.
+
+## The Meaning of Telo
+
+The name Telo is derived from the Greek root Telos - meaning the "end goal", "purpose", or "final state". That is exactly the philosophy behind this runtime. In standard imperative programming, you have to write thousands of lines of code to tell a server exactly how to start. With Telo, you simply declare your desired final state.
+
+You define the end state. Telo makes it real.
+
+## Philosophy
+
+Modern platforms often spend disproportionate effort on technical mechanics-wiring frameworks, managing infrastructure, and negotiating toolchains-while the original business problem gets delayed or diluted. Telo pushes in the opposite direction: it treats kernel execution as a stable, predictable host so teams can concentrate on the **business logic and outcomes** instead of the plumbing.
+
+By separating "what the system should do" from "how it is hosted", the runtime reduces friction for domain‑level changes. Teams can move faster on product requirements, experiment more safely, and keep conversations centered on value delivered rather than implementation trivia.
+
+Telo also aims to **join forces across all programming language communities**, so the best ideas, patterns, and implementations can converge into a shared kernel truth without forcing everyone into a single stack.
+
+YAML also makes the system more **AI‑friendly** than traditional programming languages: it is explicit, structured, and easier for tools to generate, review, and transform without losing intent.
+
+## Modularity
+
+Telo is built around **modules** that own specific resource kinds. A module is loaded from a manifest, declares which kinds it implements, and then receives only the resources of those kinds. This keeps concerns isolated and lets teams compose systems from focused building blocks rather than monolithic services.
+
+At kernel execution time, execution is always routed by **Kind.Name**. The kernel resolves the Kind to its owning module and hands off execution. Modules can call back into the kernel to execute other resources, enabling composition without tight coupling.
+
+## Architecture
+
+The architecture is inspired by Kubernetes-style manifests: declarative resources, explicit kinds, and a control plane that routes work based on those definitions.
+Those manifests were taken to the next level by allowing them to run inside a standalone runtime host.
+
+## See more at
+
+- [Telo Kernel](./kernel/README.md)
+- [CEL-YAML Templating](./yaml-cel-templating/README.md)
+- [Telo SDK for module authors](sdk/README.md)
+- [Modules](modules/README.md)
+
+## License
+
+See [LICENSE](https://github.com/telorun/telo/blob/main/LICENSE).
+
+## Contribution Note
+
+By contributing, you agree that code and examples in this repository may be translated or re‑implemented in other programming languages (including by AI systems) to support the project’s polyglot goals.

package/dist/completions/build.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisRegistry } from "@telorun/analyzer";
+import type { CompletionResult } from "../types.js";
+export declare function buildCompletions(text: string, line: number, character: number, registry: AnalysisRegistry | undefined): CompletionResult[];
+//# sourceMappingURL=build.d.ts.map

package/dist/completions/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/completions/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA0BpD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,gBAAgB,EAAE,CAMpB"}

package/dist/completions/build.js

@@ -0,0 +1,30 @@
+import { detectContext } from "./detect-context.js";
+import { propKeyCompletions } from "./prop-keys.js";
+import { CAPABILITY_VALUES } from "./valid-capabilities.js";
+function kindCompletions(registry) {
+    const kinds = new Set(registry
+        ? registry.validUserFacingKinds()
+        : ["Telo.Application", "Telo.Library", "Telo.Import", "Telo.Definition"]);
+    return Array.from(kinds).map((kind) => ({
+        label: kind,
+        kind: "class",
+        detail: "Telo resource kind",
+    }));
+}
+function capabilityCompletions() {
+    return CAPABILITY_VALUES.map((cap) => ({
+        label: cap,
+        kind: "enumMember",
+        detail: "Telo capability",
+    }));
+}
+export function buildCompletions(text, line, character, registry) {
+    const ctx = detectContext(text, line, character);
+    if (!ctx)
+        return [];
+    if (ctx.type === "kind")
+        return kindCompletions(registry);
+    if (ctx.type === "capability")
+        return capabilityCompletions();
+    return propKeyCompletions(ctx.docKind, ctx.yamlPath, ctx.existingKeys, registry);
+}

package/dist/completions/detect-context.d.ts

@@ -0,0 +1,34 @@
+export type CompletionCtx = {
+    type: "kind";
+} | {
+    type: "capability";
+} | {
+    type: "prop-key";
+    docKind: string;
+    yamlPath: string[];
+    existingKeys: Set<string>;
+};
+export declare function findDocBounds(lines: string[], cursorLine: number): {
+    start: number;
+    end: number;
+};
+export declare function extractKindFromDoc(lines: string[], start: number, end: number): string | undefined;
+export declare function extractRootKeys(lines: string[], start: number, end: number): Set<string>;
+/** Walk backward from cursorLine to build the chain of parent YAML keys. */
+export declare function buildYamlPath(lines: string[], cursorLine: number, docStart: number, cursorIndent: number): string[];
+/** Extract sibling keys already present at `indent` within the doc bounds. */
+export declare function extractKeysAtIndent(lines: string[], start: number, end: number, indent: number): Set<string>;
+/** Navigate a JSON Schema hierarchy following `path`, auto-descending into array items. */
+export declare function navigateSchema(schema: Record<string, any>, path: string[]): Record<string, any> | undefined;
+/**
+ * For blank lines (and lines with only whitespace), infer the intended indent
+ * from context rather than relying on the cursor column, which is often 0
+ * even when the cursor is semantically inside a nested block.
+ *
+ * Strategy: look at the previous non-empty line.
+ *   - If it ends with `:` (bare object key, no value) → cursor is one level deeper.
+ *   - Otherwise → cursor is a sibling of that key (same indent).
+ */
+export declare function inferIndentForBlankLine(lines: string[], cursorLine: number, docStart: number): number;
+export declare function detectContext(text: string, line: number, character: number): CompletionCtx | undefined;
+//# sourceMappingURL=detect-context.d.ts.map

package/dist/completions/detect-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-context.d.ts","sourceRoot":"","sources":["../../src/completions/detect-context.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEzF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAgBjG;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMlG;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAOxF;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,MAAM,EAAE,CA2BV;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,GAAG,CAAC,MAAM,CAAC,CAab;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,EAAE,MAAM,EAAE,GACb,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAgBjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYrG;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,aAAa,GAAG,SAAS,CAuC3B"}

package/dist/completions/detect-context.js

@@ -0,0 +1,154 @@
+export function findDocBounds(lines, cursorLine) {
+    let start = 0;
+    for (let i = cursorLine; i >= 0; i--) {
+        if (lines[i]?.trimEnd() === "---") {
+            start = i + 1;
+            break;
+        }
+    }
+    let end = lines.length;
+    for (let i = cursorLine + 1; i < lines.length; i++) {
+        if (lines[i]?.trimEnd() === "---") {
+            end = i;
+            break;
+        }
+    }
+    return { start, end };
+}
+export function extractKindFromDoc(lines, start, end) {
+    for (let i = start; i < end; i++) {
+        const m = lines[i]?.match(/^kind:\s*(\S+)/);
+        if (m)
+            return m[1];
+    }
+    return undefined;
+}
+export function extractRootKeys(lines, start, end) {
+    const keys = new Set();
+    for (let i = start; i < end; i++) {
+        const m = lines[i]?.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+        if (m)
+            keys.add(m[1]);
+    }
+    return keys;
+}
+/** Walk backward from cursorLine to build the chain of parent YAML keys. */
+export function buildYamlPath(lines, cursorLine, docStart, cursorIndent) {
+    if (cursorIndent === 0)
+        return [];
+    const path = [];
+    let targetIndent = cursorIndent;
+    for (let i = cursorLine - 1; i >= docStart; i--) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trimStart();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        const lineIndent = line.length - trimmed.length;
+        if (lineIndent < targetIndent) {
+            // Match a plain object key (not a list item marker)
+            const m = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+            if (m) {
+                path.unshift(m[1]);
+                targetIndent = lineIndent;
+                if (lineIndent === 0)
+                    break;
+            }
+            else {
+                // Hit something we can't parse (e.g. a list item `- ...`); stop
+                break;
+            }
+        }
+    }
+    return path;
+}
+/** Extract sibling keys already present at `indent` within the doc bounds. */
+export function extractKeysAtIndent(lines, start, end, indent) {
+    const keys = new Set();
+    const prefix = " ".repeat(indent);
+    for (let i = start; i < end; i++) {
+        const line = lines[i] ?? "";
+        if (!line.startsWith(prefix))
+            continue;
+        const rest = line.slice(indent);
+        const m = rest.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+        if (m && line.length - line.trimStart().length === indent) {
+            keys.add(m[1]);
+        }
+    }
+    return keys;
+}
+/** Navigate a JSON Schema hierarchy following `path`, auto-descending into array items. */
+export function navigateSchema(schema, path) {
+    let current = schema;
+    for (const segment of path) {
+        // Auto-descend through arrays before looking up the next key
+        while (current.type === "array" && current.items) {
+            current = current.items;
+        }
+        const props = current.properties;
+        if (!props?.[segment])
+            return undefined;
+        current = props[segment];
+    }
+    // Auto-descend through a trailing array at the leaf (e.g. cursor inside `mounts:` items)
+    while (current.type === "array" && current.items) {
+        current = current.items;
+    }
+    return current;
+}
+/**
+ * For blank lines (and lines with only whitespace), infer the intended indent
+ * from context rather than relying on the cursor column, which is often 0
+ * even when the cursor is semantically inside a nested block.
+ *
+ * Strategy: look at the previous non-empty line.
+ *   - If it ends with `:` (bare object key, no value) → cursor is one level deeper.
+ *   - Otherwise → cursor is a sibling of that key (same indent).
+ */
+export function inferIndentForBlankLine(lines, cursorLine, docStart) {
+    for (let i = cursorLine - 1; i >= docStart; i--) {
+        const line = lines[i] ?? "";
+        if (line.trim() === "" || line.trim().startsWith("#"))
+            continue;
+        if (line.trimEnd() === "---")
+            break;
+        const lineIndent = line.length - line.trimStart().length;
+        if (line.trimEnd().endsWith(":")) {
+            return lineIndent + 2;
+        }
+        return lineIndent;
+    }
+    return 0;
+}
+export function detectContext(text, line, character) {
+    const lines = text.split("\n");
+    const currentLine = lines[line] ?? "";
+    // Kind value completion: `kind: ` or `kind: SomePrefix`
+    if (/^kind:\s*\S*$/.test(currentLine)) {
+        return { type: "kind" };
+    }
+    const { start, end } = findDocBounds(lines, line);
+    const docKind = extractKindFromDoc(lines, start, end);
+    // Capability value completion: only inside Telo.Definition docs
+    if (/^capability:\s*\S*$/.test(currentLine) && docKind === "Telo.Definition") {
+        return { type: "capability" };
+    }
+    if (!docKind)
+        return undefined;
+    const trimmed = currentLine.trim();
+    // Only trigger when the line looks like a key being typed (or is blank)
+    const isKeyLine = trimmed === "" || /^[a-zA-Z_][a-zA-Z0-9_]*:?$/.test(trimmed);
+    if (!isKeyLine)
+        return undefined;
+    const indent = trimmed === ""
+        ? inferIndentForBlankLine(lines, line, start)
+        : currentLine.length - currentLine.trimStart().length;
+    if (indent === 0) {
+        return { type: "prop-key", docKind, yamlPath: [], existingKeys: extractRootKeys(lines, start, end) };
+    }
+    const yamlPath = buildYamlPath(lines, line, start, indent);
+    if (yamlPath.length === 0)
+        return undefined; // couldn't resolve parent — bail
+    const existingKeys = extractKeysAtIndent(lines, start, end, indent);
+    return { type: "prop-key", docKind, yamlPath, existingKeys };
+}

package/dist/completions/index.d.ts

@@ -0,0 +1,3 @@
+export { buildCompletions } from "./build.js";
+export type { CompletionCtx } from "./detect-context.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/completions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/completions/index.js

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

package/dist/completions/prop-keys.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisRegistry } from "@telorun/analyzer";
+import type { CompletionResult } from "../types.js";
+export declare function propKeyCompletions(kind: string, yamlPath: string[], existingKeys: Set<string>, registry: AnalysisRegistry | undefined): CompletionResult[];
+//# sourceMappingURL=prop-keys.d.ts.map

package/dist/completions/prop-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-keys.d.ts","sourceRoot":"","sources":["../../src/completions/prop-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GACrC,gBAAgB,EAAE,CA+CpB"}

package/dist/completions/prop-keys.js

@@ -0,0 +1,45 @@
+import { navigateSchema } from "./detect-context.js";
+export function propKeyCompletions(kind, yamlPath, existingKeys, registry) {
+    if (!registry)
+        return [];
+    const definition = registry.resolveDefinition(kind);
+    if (!definition?.schema)
+        return [];
+    const targetSchema = yamlPath.length === 0
+        ? definition.schema
+        : navigateSchema(definition.schema, yamlPath);
+    if (!targetSchema?.properties)
+        return [];
+    const required = new Set(Array.isArray(targetSchema.required) ? targetSchema.required : []);
+    const items = [];
+    for (const [prop, propSchema] of Object.entries(targetSchema.properties)) {
+        if (existingKeys.has(prop))
+            continue;
+        if (yamlPath.length === 0 && (prop === "kind" || prop === "metadata"))
+            continue;
+        const item = {
+            label: prop,
+            kind: "property",
+            insertText: `${prop}: $0`,
+            snippet: true,
+        };
+        const parts = [];
+        if (propSchema.type)
+            parts.push(propSchema.type);
+        if (propSchema.default !== undefined)
+            parts.push(`default: ${JSON.stringify(propSchema.default)}`);
+        if (parts.length)
+            item.detail = parts.join("  ");
+        if (propSchema.description)
+            item.documentation = propSchema.description;
+        if (required.has(prop)) {
+            item.preselect = true;
+            item.sortText = `0_${prop}`;
+        }
+        else {
+            item.sortText = `1_${prop}`;
+        }
+        items.push(item);
+    }
+    return items;
+}

package/dist/completions/valid-capabilities.d.ts

@@ -0,0 +1,2 @@
+export declare const CAPABILITY_VALUES: readonly ["Telo.Service", "Telo.Runnable", "Telo.Invocable", "Telo.Provider", "Telo.Mount", "Telo.Type"];
+//# sourceMappingURL=valid-capabilities.d.ts.map

package/dist/completions/valid-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-capabilities.d.ts","sourceRoot":"","sources":["../../src/completions/valid-capabilities.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,0GAOpB,CAAC"}

package/dist/completions/valid-capabilities.js

@@ -0,0 +1,8 @@
+export const CAPABILITY_VALUES = [
+    "Telo.Service",
+    "Telo.Runnable",
+    "Telo.Invocable",
+    "Telo.Provider",
+    "Telo.Mount",
+    "Telo.Type",
+];

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,4 @@
+export { normalizeDiagnostic } from "./normalize.js";
+export { resolveRange } from "./range-resolver.js";
+export { resolveSeverity } from "./severity.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diagnostics/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/diagnostics/index.js

@@ -0,0 +1,3 @@
+export { normalizeDiagnostic } from "./normalize.js";
+export { resolveRange } from "./range-resolver.js";
+export { resolveSeverity } from "./severity.js";

package/dist/diagnostics/normalize.d.ts

@@ -0,0 +1,11 @@
+import type { AnalysisDiagnostic } from "@telorun/analyzer";
+import type { DiagnosticContext, NormalizedDiagnostic } from "../types.js";
+/** Converts a raw analyzer diagnostic into a host-ready shape:
+ *    - Guarantees `range` and `severity`.
+ *    - Surfaces `data.suggestedKind` (stamped by the analyzer for UNDEFINED_KIND)
+ *      as a structured `{ kind: "replace-kind", replacement }` entry in
+ *      `suggestions`, which editor hosts can wire into CodeActions.
+ *  Does not rewrite the message — the analyzer already formatted the human-readable
+ *  "Did you mean '…'?" hint, keeping CLI and IDE output in sync. */
+export declare function normalizeDiagnostic(d: AnalysisDiagnostic, ctx: DiagnosticContext): NormalizedDiagnostic;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/diagnostics/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/diagnostics/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAI3E;;;;;;oEAMoE;AACpE,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,kBAAkB,EACrB,GAAG,EAAE,iBAAiB,GACrB,oBAAoB,CActB"}

package/dist/diagnostics/normalize.js

@@ -0,0 +1,23 @@
+import { resolveRange } from "./range-resolver.js";
+import { resolveSeverity } from "./severity.js";
+/** Converts a raw analyzer diagnostic into a host-ready shape:
+ *    - Guarantees `range` and `severity`.
+ *    - Surfaces `data.suggestedKind` (stamped by the analyzer for UNDEFINED_KIND)
+ *      as a structured `{ kind: "replace-kind", replacement }` entry in
+ *      `suggestions`, which editor hosts can wire into CodeActions.
+ *  Does not rewrite the message — the analyzer already formatted the human-readable
+ *  "Did you mean '…'?" hint, keeping CLI and IDE output in sync. */
+export function normalizeDiagnostic(d, ctx) {
+    const suggestedKind = d.data?.suggestedKind;
+    const suggestions = suggestedKind
+        ? [{ kind: "replace-kind", replacement: suggestedKind }]
+        : undefined;
+    return {
+        range: resolveRange(d, ctx),
+        severity: resolveSeverity(d),
+        code: d.code !== undefined ? String(d.code) : "",
+        source: d.source ?? "telo",
+        message: d.message,
+        ...(suggestions ? { suggestions } : {}),
+    };
+}

package/dist/diagnostics/range-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisDiagnostic, Range } from "@telorun/analyzer";
+import type { DiagnosticContext } from "../types.js";
+/** Falls back through the chain from the VS Code extension's inline resolver
+ *  (ide/vscode/src/extension.ts:203-216 before this package existed):
+ *    1. `d.range` if present.
+ *    2. `positionIndex.get(d.data.path)` when both are available.
+ *    3. Whole-line span at `sourceLine` when known.
+ *    4. `(0,0)-(0,0)` as a last resort. Never undefined. */
+export declare function resolveRange(d: AnalysisDiagnostic, ctx: DiagnosticContext): Range;
+//# sourceMappingURL=range-resolver.d.ts.map

package/dist/diagnostics/range-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-resolver.d.ts","sourceRoot":"","sources":["../../src/diagnostics/range-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD;;;;;4DAK4D;AAC5D,wBAAgB,YAAY,CAAC,CAAC,EAAE,kBAAkB,EAAE,GAAG,EAAE,iBAAiB,GAAG,KAAK,CAiBjF"}

package/dist/diagnostics/range-resolver.js

@@ -0,0 +1,27 @@
+const ZERO_RANGE = {
+    start: { line: 0, character: 0 },
+    end: { line: 0, character: 0 },
+};
+/** Falls back through the chain from the VS Code extension's inline resolver
+ *  (ide/vscode/src/extension.ts:203-216 before this package existed):
+ *    1. `d.range` if present.
+ *    2. `positionIndex.get(d.data.path)` when both are available.
+ *    3. Whole-line span at `sourceLine` when known.
+ *    4. `(0,0)-(0,0)` as a last resort. Never undefined. */
+export function resolveRange(d, ctx) {
+    if (d.range)
+        return d.range;
+    const fieldPath = d.data?.path;
+    if (fieldPath !== undefined && ctx.positionIndex) {
+        const fieldRange = ctx.positionIndex.get(fieldPath);
+        if (fieldRange)
+            return fieldRange;
+    }
+    if (ctx.sourceLine !== undefined) {
+        return {
+            start: { line: ctx.sourceLine, character: 0 },
+            end: { line: ctx.sourceLine, character: Number.MAX_SAFE_INTEGER },
+        };
+    }
+    return ZERO_RANGE;
+}

package/dist/diagnostics/severity.d.ts

@@ -0,0 +1,6 @@
+import type { AnalysisDiagnostic } from "@telorun/analyzer";
+import { DiagnosticSeverity } from "@telorun/analyzer";
+/** Resolves a possibly-undefined analyzer severity to a concrete level.
+ *  `Warning` is the default — matches VS Code adapter's prior inline behavior. */
+export declare function resolveSeverity(d: AnalysisDiagnostic): DiagnosticSeverity;
+//# sourceMappingURL=severity.d.ts.map

package/dist/diagnostics/severity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"severity.d.ts","sourceRoot":"","sources":["../../src/diagnostics/severity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;kFACkF;AAClF,wBAAgB,eAAe,CAAC,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,CAEzE"}

package/dist/diagnostics/severity.js

@@ -0,0 +1,6 @@
+import { DiagnosticSeverity } from "@telorun/analyzer";
+/** Resolves a possibly-undefined analyzer severity to a concrete level.
+ *  `Warning` is the default — matches VS Code adapter's prior inline behavior. */
+export function resolveSeverity(d) {
+    return d.severity ?? DiagnosticSeverity.Warning;
+}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./completions/index.js";
+export * from "./diagnostics/index.js";

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+export { AnalysisRegistry, DiagnosticSeverity } from "@telorun/analyzer";
+export type { Position, Range, AnalysisDiagnostic, PositionIndex, } from "@telorun/analyzer";
+import type { AnalysisRegistry, DiagnosticSeverity, PositionIndex, Range } from "@telorun/analyzer";
+export type CompletionKind = "class" | "enumMember" | "property";
+export interface CompletionResult {
+    label: string;
+    kind: CompletionKind;
+    detail?: string;
+    documentation?: string;
+    insertText?: string;
+    snippet?: boolean;
+    preselect?: boolean;
+    sortText?: string;
+}
+export interface NormalizedDiagnostic {
+    range: Range;
+    severity: DiagnosticSeverity;
+    code: string;
+    source: string;
+    message: string;
+    suggestions?: Array<{
+        kind: "replace-kind";
+        replacement: string;
+    }>;
+}
+export interface DiagnosticContext {
+    registry: AnalysisRegistry;
+    positionIndex?: PositionIndex;
+    sourceLine?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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,CAAC;AAEjE,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;CACnB;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;CACpE;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

@@ -0,0 +1,3 @@
+// Runtime values (classes, enums) — consumers who need `new AnalysisRegistry()`
+// or `DiagnosticSeverity.Error` import from here.
+export { AnalysisRegistry, DiagnosticSeverity } from "@telorun/analyzer";

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@telorun/ide-support",
+  "version": "0.2.0",
+  "description": "Editor-host-agnostic IDE support (completions, diagnostic normalization) for Telo manifests.",
+  "keywords": [
+    "telo",
+    "ide",
+    "completions",
+    "diagnostics",
+    "yaml"
+  ],
+  "author": "Bartosz Pasiński <bartosz.pasinski@codenet.pl>",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telorun/telo.git",
+    "directory": "packages/ide-support"
+  },
+  "homepage": "https://github.com/telorun/telo#readme",
+  "bugs": {
+    "url": "https://github.com/telorun/telo/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "src/**"
+  ],
+  "dependencies": {
+    "@telorun/analyzer": "0.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  }
+}

package/src/completions/build.ts

@@ -0,0 +1,39 @@
+import type { AnalysisRegistry } from "@telorun/analyzer";
+import type { CompletionResult } from "../types.js";
+import { detectContext } from "./detect-context.js";
+import { propKeyCompletions } from "./prop-keys.js";
+import { CAPABILITY_VALUES } from "./valid-capabilities.js";
+
+function kindCompletions(registry: AnalysisRegistry | undefined): CompletionResult[] {
+  const kinds = new Set<string>(
+    registry
+      ? registry.validUserFacingKinds()
+      : ["Telo.Application", "Telo.Library", "Telo.Import", "Telo.Definition"],
+  );
+  return Array.from(kinds).map((kind) => ({
+    label: kind,
+    kind: "class",
+    detail: "Telo resource kind",
+  }));
+}
+
+function capabilityCompletions(): CompletionResult[] {
+  return CAPABILITY_VALUES.map((cap) => ({
+    label: cap,
+    kind: "enumMember",
+    detail: "Telo capability",
+  }));
+}
+
+export function buildCompletions(
+  text: string,
+  line: number,
+  character: number,
+  registry: AnalysisRegistry | undefined,
+): CompletionResult[] {
+  const ctx = detectContext(text, line, character);
+  if (!ctx) return [];
+  if (ctx.type === "kind") return kindCompletions(registry);
+  if (ctx.type === "capability") return capabilityCompletions();
+  return propKeyCompletions(ctx.docKind, ctx.yamlPath, ctx.existingKeys, registry);
+}

package/src/completions/detect-context.ts

@@ -0,0 +1,185 @@
+export type CompletionCtx =
+  | { type: "kind" }
+  | { type: "capability" }
+  | { type: "prop-key"; docKind: string; yamlPath: string[]; existingKeys: Set<string> };
+
+export function findDocBounds(lines: string[], cursorLine: number): { start: number; end: number } {
+  let start = 0;
+  for (let i = cursorLine; i >= 0; i--) {
+    if (lines[i]?.trimEnd() === "---") {
+      start = i + 1;
+      break;
+    }
+  }
+  let end = lines.length;
+  for (let i = cursorLine + 1; i < lines.length; i++) {
+    if (lines[i]?.trimEnd() === "---") {
+      end = i;
+      break;
+    }
+  }
+  return { start, end };
+}
+
+export function extractKindFromDoc(lines: string[], start: number, end: number): string | undefined {
+  for (let i = start; i < end; i++) {
+    const m = lines[i]?.match(/^kind:\s*(\S+)/);
+    if (m) return m[1];
+  }
+  return undefined;
+}
+
+export function extractRootKeys(lines: string[], start: number, end: number): Set<string> {
+  const keys = new Set<string>();
+  for (let i = start; i < end; i++) {
+    const m = lines[i]?.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+    if (m) keys.add(m[1]);
+  }
+  return keys;
+}
+
+/** Walk backward from cursorLine to build the chain of parent YAML keys. */
+export function buildYamlPath(
+  lines: string[],
+  cursorLine: number,
+  docStart: number,
+  cursorIndent: number,
+): string[] {
+  if (cursorIndent === 0) return [];
+
+  const path: string[] = [];
+  let targetIndent = cursorIndent;
+
+  for (let i = cursorLine - 1; i >= docStart; i--) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trimStart();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+
+    const lineIndent = line.length - trimmed.length;
+    if (lineIndent < targetIndent) {
+      // Match a plain object key (not a list item marker)
+      const m = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+      if (m) {
+        path.unshift(m[1]);
+        targetIndent = lineIndent;
+        if (lineIndent === 0) break;
+      } else {
+        // Hit something we can't parse (e.g. a list item `- ...`); stop
+        break;
+      }
+    }
+  }
+
+  return path;
+}
+
+/** Extract sibling keys already present at `indent` within the doc bounds. */
+export function extractKeysAtIndent(
+  lines: string[],
+  start: number,
+  end: number,
+  indent: number,
+): Set<string> {
+  const keys = new Set<string>();
+  const prefix = " ".repeat(indent);
+  for (let i = start; i < end; i++) {
+    const line = lines[i] ?? "";
+    if (!line.startsWith(prefix)) continue;
+    const rest = line.slice(indent);
+    const m = rest.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+    if (m && line.length - line.trimStart().length === indent) {
+      keys.add(m[1]);
+    }
+  }
+  return keys;
+}
+
+/** Navigate a JSON Schema hierarchy following `path`, auto-descending into array items. */
+export function navigateSchema(
+  schema: Record<string, any>,
+  path: string[],
+): Record<string, any> | undefined {
+  let current = schema;
+  for (const segment of path) {
+    // Auto-descend through arrays before looking up the next key
+    while (current.type === "array" && current.items) {
+      current = current.items as Record<string, any>;
+    }
+    const props = current.properties as Record<string, any> | undefined;
+    if (!props?.[segment]) return undefined;
+    current = props[segment] as Record<string, any>;
+  }
+  // Auto-descend through a trailing array at the leaf (e.g. cursor inside `mounts:` items)
+  while (current.type === "array" && current.items) {
+    current = current.items as Record<string, any>;
+  }
+  return current;
+}
+
+/**
+ * For blank lines (and lines with only whitespace), infer the intended indent
+ * from context rather than relying on the cursor column, which is often 0
+ * even when the cursor is semantically inside a nested block.
+ *
+ * Strategy: look at the previous non-empty line.
+ *   - If it ends with `:` (bare object key, no value) → cursor is one level deeper.
+ *   - Otherwise → cursor is a sibling of that key (same indent).
+ */
+export function inferIndentForBlankLine(lines: string[], cursorLine: number, docStart: number): number {
+  for (let i = cursorLine - 1; i >= docStart; i--) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    if (line.trimEnd() === "---") break;
+    const lineIndent = line.length - line.trimStart().length;
+    if (line.trimEnd().endsWith(":")) {
+      return lineIndent + 2;
+    }
+    return lineIndent;
+  }
+  return 0;
+}
+
+export function detectContext(
+  text: string,
+  line: number,
+  character: number,
+): CompletionCtx | undefined {
+  const lines = text.split("\n");
+  const currentLine = lines[line] ?? "";
+
+  // Kind value completion: `kind: ` or `kind: SomePrefix`
+  if (/^kind:\s*\S*$/.test(currentLine)) {
+    return { type: "kind" };
+  }
+
+  const { start, end } = findDocBounds(lines, line);
+  const docKind = extractKindFromDoc(lines, start, end);
+
+  // Capability value completion: only inside Telo.Definition docs
+  if (/^capability:\s*\S*$/.test(currentLine) && docKind === "Telo.Definition") {
+    return { type: "capability" };
+  }
+
+  if (!docKind) return undefined;
+
+  const trimmed = currentLine.trim();
+
+  // Only trigger when the line looks like a key being typed (or is blank)
+  const isKeyLine = trimmed === "" || /^[a-zA-Z_][a-zA-Z0-9_]*:?$/.test(trimmed);
+  if (!isKeyLine) return undefined;
+
+  const indent =
+    trimmed === ""
+      ? inferIndentForBlankLine(lines, line, start)
+      : currentLine.length - currentLine.trimStart().length;
+
+  if (indent === 0) {
+    return { type: "prop-key", docKind, yamlPath: [], existingKeys: extractRootKeys(lines, start, end) };
+  }
+
+  const yamlPath = buildYamlPath(lines, line, start, indent);
+  if (yamlPath.length === 0) return undefined; // couldn't resolve parent — bail
+
+  const existingKeys = extractKeysAtIndent(lines, start, end, indent);
+  return { type: "prop-key", docKind, yamlPath, existingKeys };
+}

package/src/completions/index.ts

@@ -0,0 +1,2 @@
+export { buildCompletions } from "./build.js";
+export type { CompletionCtx } from "./detect-context.js";

package/src/completions/prop-keys.ts

@@ -0,0 +1,57 @@
+import type { AnalysisRegistry } from "@telorun/analyzer";
+import type { CompletionResult } from "../types.js";
+import { navigateSchema } from "./detect-context.js";
+
+export function propKeyCompletions(
+  kind: string,
+  yamlPath: string[],
+  existingKeys: Set<string>,
+  registry: AnalysisRegistry | undefined,
+): CompletionResult[] {
+  if (!registry) return [];
+
+  const definition = registry.resolveDefinition(kind);
+  if (!definition?.schema) return [];
+
+  const targetSchema = yamlPath.length === 0
+    ? (definition.schema as Record<string, any>)
+    : navigateSchema(definition.schema as Record<string, any>, yamlPath);
+
+  if (!targetSchema?.properties) return [];
+
+  const required = new Set<string>(
+    Array.isArray(targetSchema.required) ? targetSchema.required : [],
+  );
+  const items: CompletionResult[] = [];
+
+  for (const [prop, propSchema] of Object.entries(
+    targetSchema.properties as Record<string, any>,
+  )) {
+    if (existingKeys.has(prop)) continue;
+    if (yamlPath.length === 0 && (prop === "kind" || prop === "metadata")) continue;
+
+    const item: CompletionResult = {
+      label: prop,
+      kind: "property",
+      insertText: `${prop}: $0`,
+      snippet: true,
+    };
+
+    const parts: string[] = [];
+    if (propSchema.type) parts.push(propSchema.type);
+    if (propSchema.default !== undefined) parts.push(`default: ${JSON.stringify(propSchema.default)}`);
+    if (parts.length) item.detail = parts.join("  ");
+    if (propSchema.description) item.documentation = propSchema.description;
+
+    if (required.has(prop)) {
+      item.preselect = true;
+      item.sortText = `0_${prop}`;
+    } else {
+      item.sortText = `1_${prop}`;
+    }
+
+    items.push(item);
+  }
+
+  return items;
+}

package/src/completions/valid-capabilities.ts

@@ -0,0 +1,8 @@
+export const CAPABILITY_VALUES = [
+  "Telo.Service",
+  "Telo.Runnable",
+  "Telo.Invocable",
+  "Telo.Provider",
+  "Telo.Mount",
+  "Telo.Type",
+] as const;

package/src/diagnostics/index.ts

@@ -0,0 +1,3 @@
+export { normalizeDiagnostic } from "./normalize.js";
+export { resolveRange } from "./range-resolver.js";
+export { resolveSeverity } from "./severity.js";

package/src/diagnostics/normalize.ts

@@ -0,0 +1,30 @@
+import type { AnalysisDiagnostic } from "@telorun/analyzer";
+import type { DiagnosticContext, NormalizedDiagnostic } from "../types.js";
+import { resolveRange } from "./range-resolver.js";
+import { resolveSeverity } from "./severity.js";
+
+/** Converts a raw analyzer diagnostic into a host-ready shape:
+ *    - Guarantees `range` and `severity`.
+ *    - Surfaces `data.suggestedKind` (stamped by the analyzer for UNDEFINED_KIND)
+ *      as a structured `{ kind: "replace-kind", replacement }` entry in
+ *      `suggestions`, which editor hosts can wire into CodeActions.
+ *  Does not rewrite the message — the analyzer already formatted the human-readable
+ *  "Did you mean '…'?" hint, keeping CLI and IDE output in sync. */
+export function normalizeDiagnostic(
+  d: AnalysisDiagnostic,
+  ctx: DiagnosticContext,
+): NormalizedDiagnostic {
+  const suggestedKind = (d.data as { suggestedKind?: string } | undefined)?.suggestedKind;
+  const suggestions = suggestedKind
+    ? [{ kind: "replace-kind" as const, replacement: suggestedKind }]
+    : undefined;
+
+  return {
+    range: resolveRange(d, ctx),
+    severity: resolveSeverity(d),
+    code: d.code !== undefined ? String(d.code) : "",
+    source: d.source ?? "telo",
+    message: d.message,
+    ...(suggestions ? { suggestions } : {}),
+  };
+}

package/src/diagnostics/range-resolver.ts

@@ -0,0 +1,32 @@
+import type { AnalysisDiagnostic, Range } from "@telorun/analyzer";
+import type { DiagnosticContext } from "../types.js";
+
+const ZERO_RANGE: Range = {
+  start: { line: 0, character: 0 },
+  end: { line: 0, character: 0 },
+};
+
+/** Falls back through the chain from the VS Code extension's inline resolver
+ *  (ide/vscode/src/extension.ts:203-216 before this package existed):
+ *    1. `d.range` if present.
+ *    2. `positionIndex.get(d.data.path)` when both are available.
+ *    3. Whole-line span at `sourceLine` when known.
+ *    4. `(0,0)-(0,0)` as a last resort. Never undefined. */
+export function resolveRange(d: AnalysisDiagnostic, ctx: DiagnosticContext): Range {
+  if (d.range) return d.range;
+
+  const fieldPath = (d.data as { path?: string } | undefined)?.path;
+  if (fieldPath !== undefined && ctx.positionIndex) {
+    const fieldRange = ctx.positionIndex.get(fieldPath);
+    if (fieldRange) return fieldRange;
+  }
+
+  if (ctx.sourceLine !== undefined) {
+    return {
+      start: { line: ctx.sourceLine, character: 0 },
+      end: { line: ctx.sourceLine, character: Number.MAX_SAFE_INTEGER },
+    };
+  }
+
+  return ZERO_RANGE;
+}

package/src/diagnostics/severity.ts

@@ -0,0 +1,8 @@
+import type { AnalysisDiagnostic } from "@telorun/analyzer";
+import { DiagnosticSeverity } from "@telorun/analyzer";
+
+/** Resolves a possibly-undefined analyzer severity to a concrete level.
+ *  `Warning` is the default — matches VS Code adapter's prior inline behavior. */
+export function resolveSeverity(d: AnalysisDiagnostic): DiagnosticSeverity {
+  return d.severity ?? DiagnosticSeverity.Warning;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./completions/index.js";
+export * from "./diagnostics/index.js";

package/src/types.ts

@@ -0,0 +1,41 @@
+// Runtime values (classes, enums) — consumers who need `new AnalysisRegistry()`
+// or `DiagnosticSeverity.Error` import from here.
+export { AnalysisRegistry, DiagnosticSeverity } from "@telorun/analyzer";
+
+// Pure types.
+export type {
+  Position,
+  Range,
+  AnalysisDiagnostic,
+  PositionIndex,
+} from "@telorun/analyzer";
+
+import type { AnalysisRegistry, DiagnosticSeverity, PositionIndex, Range } from "@telorun/analyzer";
+
+export type CompletionKind = "class" | "enumMember" | "property";
+
+export interface CompletionResult {
+  label: string;
+  kind: CompletionKind;
+  detail?: string;
+  documentation?: string;
+  insertText?: string;
+  snippet?: boolean;
+  preselect?: boolean;
+  sortText?: string;
+}
+
+export interface NormalizedDiagnostic {
+  range: Range;
+  severity: DiagnosticSeverity;
+  code: string;
+  source: string;
+  message: string;
+  suggestions?: Array<{ kind: "replace-kind"; replacement: string }>;
+}
+
+export interface DiagnosticContext {
+  registry: AnalysisRegistry;
+  positionIndex?: PositionIndex;
+  sourceLine?: number;
+}