@telorun/ide-support 0.13.3 → 0.14.1

package/dist/rename/types.d.ts

@@ -0,0 +1,55 @@
+import type { Range } from "../types.js";
+/**
+ * Which naming surface a rename targets. Only the value-level, module-local
+ * ones are supported — see `build-rename.ts` for why each of the others is a
+ * refusal rather than an omission.
+ */
+export type RenameSymbolKind = 
+/** A resource instance's `metadata.name`. */
+"resource"
+/** A `name:` on a step inside a step array. */
+ | "step"
+/** A key of the module doc's `variables:` / `secrets:` / `ports:` block. */
+ | "declaration";
+/** What the cursor resolved to, and the span the host pre-fills in its rename
+ *  box. `block` is set only for a `declaration`. */
+export interface RenameSymbol {
+    kind: RenameSymbolKind;
+    name: string;
+    range: Range;
+    block?: "variables" | "secrets" | "ports";
+}
+/** One replacement. `range` is a source span in `uri`; `newText` replaces it
+ *  wholesale. Spans never overlap and never cross a line, because every site is
+ *  either a bare scalar value or an identifier inside one. */
+export interface RenameEdit {
+    range: Range;
+    newText: string;
+}
+export interface RenameFileEdits {
+    uri: string;
+    edits: RenameEdit[];
+}
+/**
+ * A refusal carries the reason, always. A rename the tool declines is a
+ * decision the author has to act on — silently returning "nothing to rename"
+ * would read as "this name has no references", which is the opposite of what a
+ * refusal usually means here (an exported name has too many, in files this
+ * workspace cannot see).
+ */
+export type RenamePreparation = {
+    ok: true;
+    symbol: RenameSymbol;
+} | {
+    ok: false;
+    reason: string;
+};
+export type RenameResult = {
+    ok: true;
+    symbol: RenameSymbol;
+    files: RenameFileEdits[];
+} | {
+    ok: false;
+    reason: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/rename/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rename/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;GAIG;AACH,MAAM,MAAM,gBAAgB;AAC1B,6CAA6C;AAC3C,UAAU;AACZ,+CAA+C;GAC7C,MAAM;AACR,4EAA4E;GAC1E,aAAa,CAAC;AAElB;oDACoD;AACpD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;CAC3C;AAED;;8DAE8D;AAC9D,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAClC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,MAAM,MAAM,YAAY,GACpB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,eAAe,EAAE,CAAA;CAAE,GAC5D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/rename/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

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

package/src/cel-chain.ts

@@ -0,0 +1,86 @@
+import type { CelNode } from "@telorun/analyzer";
+
+/** One identifier of a dotted CEL chain, with the span a cursor hit-tests
+ *  against and a rename replaces. */
+export interface ChainPart {
+  name: string;
+  range: [number, number];
+}
+
+/**
+ * Flatten `a.b.c` into its identifiers. Returns undefined as soon as the chain
+ * is rooted in something other than a plain identifier (a call, an index), so a
+ * navigable — or renameable — prefix is never invented out of a computed
+ * expression.
+ */
+export function flattenChain(node: CelNode): ChainPart[] | undefined {
+  if (node.kind === "ident") return [{ name: node.name, range: node.range }];
+  if (node.kind !== "member") return undefined;
+  const head = flattenChain(node.target);
+  return head ? [...head, { name: node.property, range: node.propertyRange }] : undefined;
+}
+
+/**
+ * A node's children.
+ *
+ * Exhaustive by construction: a new `CelNode` variant fails the build here
+ * rather than silently going unwalked, so the analyzer's node model and the
+ * walks over it cannot drift apart unnoticed. That matters twice over — for
+ * go-to-definition an unwalked variant is a missed jump, for a rename it is a
+ * reference left pointing at the old name.
+ */
+export function celChildren(node: CelNode): CelNode[] {
+  switch (node.kind) {
+    case "literal":
+    case "ident":
+      return [];
+    case "member":
+      return [node.target];
+    case "index":
+      return [node.target, node.index];
+    case "call":
+      return node.args;
+    case "methodCall":
+      return [node.receiver, ...node.args];
+    case "list":
+      return node.items;
+    case "map":
+      return node.entries.flatMap((e) => [e.key, e.value]);
+    case "ternary":
+      return [node.cond, node.then, node.else];
+    case "unary":
+      return [node.operand];
+    case "binary":
+      return [node.left, node.right];
+  }
+  const unhandled: never = node;
+  throw new Error(`Unhandled CEL node: ${JSON.stringify(unhandled)}`);
+}
+
+/** Every node of the tree, outermost first. */
+export function walkCel(node: CelNode, visit: (node: CelNode) => void): void {
+  visit(node);
+  for (const child of celChildren(node)) walkCel(child, visit);
+}
+
+/**
+ * The dotted chain under `offset`, and which of its identifiers was hit. The
+ * walk is outermost-first so the longest chain wins — `resources.store.conn`
+ * resolves as one chain rather than as its `resources.store` prefix.
+ */
+export function chainAt(
+  node: CelNode,
+  offset: number,
+): { parts: ChainPart[]; index: number } | undefined {
+  if (offset < node.range[0] || offset > node.range[1]) return undefined;
+  const parts = flattenChain(node);
+  if (parts) {
+    const index = parts.findIndex((p) => offset >= p.range[0] && offset <= p.range[1]);
+    if (index >= 0) return { parts, index };
+  }
+  for (const child of celChildren(node)) {
+    const hit = chainAt(child, offset);
+    if (hit) return hit;
+  }
+  return undefined;
+}

package/src/completions/detect-context.ts

@@ -66,18 +66,70 @@ function peelCombinators(node: Record<string, any>): Record<string, any>[] {
   return out;
 }
 
+/** One JSON Pointer segment: RFC 6901 escapes, then percent-decoding, which a
+ *  pointer carried in a URI fragment is subject to. A malformed escape is
+ *  returned raw rather than thrown — `decodeURIComponent` raises `URIError`, and
+ *  a stray `%` in someone's `$defs` key must not take completion down. */
+function decodePointerSegment(segment: string): string {
+  const unescaped = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+  try {
+    return decodeURIComponent(unescaped);
+  } catch {
+    return unescaped;
+  }
+}
+
+/**
+ * Follow a document-local `$ref` (`#/$defs/<Name>`) against the schema root.
+ *
+ * The one reference form that occurs inside a kind schema, and the one the
+ * editor's resolver accepts — a schema-valued slot points at the hoisted
+ * `JsonSchema7` / `KindSchema` fragment this way, and the fragment points at
+ * itself to describe a nested schema. Without the hop, completion stopped dead
+ * at the first key of every `schema:` / `status:` block.
+ *
+ * A chain ends at a REPEATED pointer, which is what bounds the walk: a
+ * self-referential fragment is the normal case here, so a cycle must degrade to
+ * "no completion" rather than hang the editor.
+ */
+function resolveLocalRef(
+  node: Record<string, any> | undefined,
+  root: Record<string, any>,
+): Record<string, any> | undefined {
+  let current = node;
+  const seen = new Set<string>();
+  while (current && typeof current.$ref === "string" && current.$ref.startsWith("#/")) {
+    const pointer = current.$ref;
+    if (seen.has(pointer)) return undefined;
+    seen.add(pointer);
+    let target: any = root;
+    for (const segment of pointer.slice(2).split("/")) {
+      target = target?.[decodePointerSegment(segment)];
+    }
+    if (!target || typeof target !== "object") return undefined;
+    // Keep whatever the slot declared beside the `$ref` (its title, its
+    // `x-telo-fragment` stamp) — that is what tells a consumer WHICH shape it
+    // pointed at, and draft-07 drops it at the validation layer only.
+    const { $ref: _, ...siblings } = current;
+    current = { ...target, ...siblings };
+  }
+  return current;
+}
+
 /** Navigate a JSON Schema hierarchy following `path`, auto-descending into
- *  array items and peeling `anyOf` / `oneOf` branches. When multiple peeled
- *  branches define `properties`, returns a synthetic node whose `properties`
- *  is the union (first-wins on key collision) and whose `required` is the
- *  intersection — enough for propKeyCompletions to surface every key a value
- *  at this slot can legally carry. */
+ *  array items, peeling `anyOf` / `oneOf` branches and following document-local
+ *  `$ref`s. When multiple peeled branches define `properties`, returns a
+ *  synthetic node whose `properties` is the union (first-wins on key collision)
+ *  and whose `required` is the intersection — enough for propKeyCompletions to
+ *  surface every key a value at this slot can legally carry. */
 export function navigateSchema(
   schema: Record<string, any>,
   path: string[],
 ): Record<string, any> | undefined {
-  let current: Record<string, any> = schema;
+  let current: Record<string, any> | undefined = schema;
   for (const segment of path) {
+    current = resolveLocalRef(current, schema);
+    if (!current) return undefined;
     const candidates = peelCombinators(current).flatMap((node) => {
       const expanded: Record<string, any>[] = [];
       let cur: Record<string, any> = node;
@@ -93,9 +145,24 @@ export function navigateSchema(
         break;
       }
     }
+    // A map-valued node (a schema's `properties:`, a kind's name-keyed field)
+    // names its entries nowhere, so every segment lands on
+    // `additionalProperties`. Without this the walk stopped one level into a
+    // `schema:` block — at exactly the field the author is writing.
+    if (!next) {
+      for (const cand of candidates) {
+        const additional = cand.additionalProperties;
+        if (additional && typeof additional === "object") {
+          next = additional as Record<string, any>;
+          break;
+        }
+      }
+    }
     if (!next) return undefined;
     current = next;
   }
+  current = resolveLocalRef(current, schema);
+  if (!current) return undefined;
   // 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>;

package/src/completions/prop-keys.ts

@@ -1,4 +1,8 @@
-import type { AnalysisRegistry } from "@telorun/analyzer";
+import {
+  manifestFragmentOf,
+  TELO_SCHEMA_ANNOTATIONS,
+  type AnalysisRegistry,
+} from "@telorun/analyzer";
 import type { CompletionResult } from "../types.js";
 import { navigateSchema } from "./detect-context.js";
 
@@ -52,11 +56,28 @@ export function propKeyCompletions(
   const properties =
     yamlPath.length === 0
       ? { ...ROOT_IMPLICIT_PROPS, ...(targetSchema.properties as Record<string, any>) }
-      : (targetSchema.properties as Record<string, any>);
+      : { ...(targetSchema.properties as Record<string, any>), ...annotationKeys(targetSchema) };
 
   return buildItems(properties, existingKeys, required);
 }
 
+/**
+ * The `x-telo-*` vocabulary, offered only inside a KIND's own schema.
+ *
+ * Read off the fragment stamp rather than the position: a kind schema nests, so
+ * "am I inside one" is a fact about the node, not about how deep the cursor
+ * sits. A plain data schema — an `inputType:`, a `status:` block — stamps
+ * `JsonSchema7` and gets nothing, because an annotation there configures a slot
+ * that does not exist.
+ *
+ * The vocabulary lives on the analyzer side and never enters a manifest: a
+ * `properties` map holding a literal `x-telo-ref` key reads to the annotation
+ * walkers as an annotated node.
+ */
+function annotationKeys(node: Record<string, any>): Record<string, any> {
+  return manifestFragmentOf(node) === "KindSchema" ? TELO_SCHEMA_ANNOTATIONS : {};
+}
+
 function buildItems(
   properties: Record<string, any>,
   existingKeys: Set<string>,

package/src/definition/resolve-cel-target.ts

@@ -13,79 +13,12 @@ import {
   moduleFiles,
 } from "./manifest-navigation.js";
 import { resolveExportedResource } from "./resolve-export-chain.js";
+import { chainAt, type ChainPart } from "../cel-chain.js";
 
 /** Root CEL scopes whose members are declared as a block on the module doc, so
  *  `variables.port` navigates to `variables:` and then to its `port:` entry. */
 const DECLARATION_SCOPES = new Set(["variables", "secrets", "ports"]);
 
-/** One identifier of a dotted CEL chain, with the span the cursor hit-tests
- *  against. */
-interface ChainPart {
-  name: string;
-  range: [number, number];
-}
-
-/** Flatten `a.b.c` into its identifiers. Returns undefined as soon as the chain
- *  is rooted in something other than a plain identifier (a call, an index), so a
- *  navigable prefix is never invented out of a computed expression. */
-function flattenChain(node: CelNode): ChainPart[] | undefined {
-  if (node.kind === "ident") return [{ name: node.name, range: node.range }];
-  if (node.kind !== "member") return undefined;
-  const head = flattenChain(node.target);
-  return head ? [...head, { name: node.property, range: node.propertyRange }] : undefined;
-}
-
-/** Exhaustive by construction: a new `CelNode` variant fails the build here
- *  rather than silently going unwalked, so the analyzer's node model and this
- *  walk cannot drift apart unnoticed. */
-function celChildren(node: CelNode): CelNode[] {
-  switch (node.kind) {
-    case "literal":
-    case "ident":
-      return [];
-    case "member":
-      return [node.target];
-    case "index":
-      return [node.target, node.index];
-    case "call":
-      return node.args;
-    case "methodCall":
-      return [node.receiver, ...node.args];
-    case "list":
-      return node.items;
-    case "map":
-      return node.entries.flatMap((e) => [e.key, e.value]);
-    case "ternary":
-      return [node.cond, node.then, node.else];
-    case "unary":
-      return [node.operand];
-    case "binary":
-      return [node.left, node.right];
-  }
-  const unhandled: never = node;
-  throw new Error(`Unhandled CEL node: ${JSON.stringify(unhandled)}`);
-}
-
-/** The dotted chain under `offset`, and which of its identifiers was hit. The
- *  walk is outermost-first so the longest chain wins — `resources.Store.conn`
- *  resolves as one chain rather than as its `resources.Store` prefix. */
-function chainAt(
-  node: CelNode,
-  offset: number,
-): { parts: ChainPart[]; index: number } | undefined {
-  if (offset < node.range[0] || offset > node.range[1]) return undefined;
-  const parts = flattenChain(node);
-  if (parts) {
-    const index = parts.findIndex((p) => offset >= p.range[0] && offset <= p.range[1]);
-    if (index >= 0) return { parts, index };
-  }
-  for (const child of celChildren(node)) {
-    const hit = chainAt(child, offset);
-    if (hit) return hit;
-  }
-  return undefined;
-}
-
 /** `resources.<name>` is a local instance; `resources.<Alias>.<name>` is an
  *  imported module's exported one. A local name wins over an import alias, so a
  *  deeper access on a local instance (`resources.db.url`) reads as a field of

package/src/index.ts

@@ -4,4 +4,5 @@ export * from "./diagnostics/index.js";
 export * from "./hover/index.js";
 export * from "./semantic-tokens/index.js";
 export * from "./definition/index.js";
+export * from "./rename/index.js";
 export * from "./import-upgrades/index.js";