@telorun/ide-support 0.6.0 → 0.7.0

package/src/completions/detect-context.ts

@@ -1,3 +1,9 @@
+import { parseToAst, type AstDocument } from "@telorun/analyzer";
+import type { ReplaceRange } from "../types.js";
+import { resolveNodeAtPosition } from "./resolve-node.js";
+
+export type { ReplaceRange };
+
 export type CompletionCtx =
   | {
       type: "kind";
@@ -7,12 +13,10 @@ export type CompletionCtx =
        *  Absent for top-level `kind:` — there, no constraint applies. */
       docKind?: string;
       yamlPath?: string[];
-      /** Column where the kind value begins (after `kind:` + whitespace).
-       *  Editor hosts use this to anchor the replace range so completions
-       *  cleanly overwrite a kind that contains `.` (e.g. `Sql.Co|` →
-       *  selecting `Sql.Connection` must replace `Sql.Co`, not just `Co`,
-       *  which VS Code's default word range would). */
-      valueStartColumn: number;
+      /** Full source range of the kind value, so a pick overwrites the whole
+       *  existing scalar (e.g. `Sql.Co|nnection` + `Sql.Connection` → no
+       *  suffix left behind). */
+      replaceRange: ReplaceRange;
     }
   | { type: "capability" }
   | { type: "prop-key"; docKind: string; yamlPath: string[]; existingKeys: Set<string> }
@@ -29,7 +33,7 @@ export type CompletionCtx =
       /** The kind value of the sibling `kind:` line, if present. */
       refKind?: string;
       prefix: string;
-      valueStartColumn: number;
+      replaceRange: ReplaceRange;
     }
   | {
       type: "field-value";
@@ -37,141 +41,10 @@ export type CompletionCtx =
       field: string;
       /** Text from the start of the value to the cursor. */
       prefix: string;
-      /** 0-based column where the value starts (right after `<field>:` + whitespace). */
-      valueStartColumn: number;
+      /** Full source range of the value being completed. */
+      replaceRange: ReplaceRange;
     };
 
-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;
-}
-
-/** Collects every top-level key in the doc bounds, skipping `skipLine` so the
- *  cursor's own line is treated as "being edited" — its key (if any) stays in
- *  the suggestion list. Without this the user can't autocomplete an existing
- *  key from its own line (e.g. `ver|sion:`). */
-export function extractRootKeys(
-  lines: string[],
-  start: number,
-  end: number,
-  skipLine?: number,
-): Set<string> {
-  const keys = new Set<string>();
-  for (let i = start; i < end; i++) {
-    if (i === skipLine) continue;
-    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.
- *
- *  List-item handling (`  - request:` style): the `-` marker sits at the
- *  line's textual indent, but the key after it (`request`) lives at indent
- *  `+2`. Whether that post-dash key joins the path depends on the cursor's
- *  descent:
- *    - When the cursor's current target indent is GREATER than the post-dash
- *      key's column, the descent passes through that key (e.g. cursor inside
- *      `request.method` at indent 6, key `request` at column 4) → push it.
- *    - When the cursor's current target indent EQUALS the post-dash key's
- *      column, the post-dash key is a sibling at the list-item level
- *      (e.g. cursor on `handler:` at indent 4, key `request:` at column 4) →
- *      skip it; descend straight to the array's parent.
- *
- *  In both cases the next walk step targets `lineIndent` so the `routes:` /
- *  `steps:` parent of the array is captured. The schema walker auto-descends
- *  arrays, so no `[]` marker is appended. */
-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 if (trimmed.startsWith("- ")) {
-        const postDash = trimmed.slice(2);
-        const km = postDash.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
-        const keyColumn = lineIndent + 2;
-        if (km && keyColumn < targetIndent) {
-          path.unshift(km[1]);
-        }
-        targetIndent = lineIndent;
-      } else if (trimmed === "-") {
-        targetIndent = lineIndent;
-      } else {
-        // Hit something we can't parse; stop
-        break;
-      }
-    }
-  }
-
-  return path;
-}
-
-/** Extract sibling keys already present at `indent` within the doc bounds.
- *  `skipLine` lets the caller exclude the cursor's own line so a key being
- *  edited (`ver|sion:`) doesn't filter itself out of the suggestion list. */
-export function extractKeysAtIndent(
-  lines: string[],
-  start: number,
-  end: number,
-  indent: number,
-  skipLine?: number,
-): Set<string> {
-  const keys = new Set<string>();
-  const prefix = " ".repeat(indent);
-  for (let i = start; i < end; i++) {
-    if (i === skipLine) continue;
-    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;
-}
-
 /** Returns every schema branch reachable from `node` after peeling `anyOf` /
  *  `oneOf` recursively. A branch with no combinators is its own only entry.
  *  Used so an `x-telo-ref` slot like `{anyOf: [{type: string}, {type: object,
@@ -272,36 +145,6 @@ function unionLeaves(
  *  completion to discover what kind of resource the user is targeting in an
  *  object-form ref. Walking stops at the first line with a strictly smaller
  *  indent (that's the parent's structural boundary). */
-export function findSiblingKindValue(
-  lines: string[],
-  docStart: number,
-  docEnd: number,
-  cursorLine: number,
-  indent: number,
-): string | undefined {
-  const prefix = " ".repeat(indent);
-  const scan = (range: number[]): string | undefined => {
-    for (const i of range) {
-      const line = lines[i] ?? "";
-      if (line.trim() === "" || line.trim().startsWith("#")) continue;
-      if (line.trimEnd() === "---") return undefined;
-      const lineIndent = line.length - line.trimStart().length;
-      if (lineIndent < indent) return undefined; // parent boundary
-      if (lineIndent !== indent || !line.startsWith(prefix)) continue;
-      const m = line.slice(indent).match(/^kind:\s*(\S+)/);
-      if (m) return m[1];
-    }
-    return undefined;
-  };
-  // Forward then backward — order doesn't matter for correctness because
-  // any sibling kind value at this indent applies to the same object.
-  const after = [];
-  for (let i = cursorLine + 1; i < docEnd; i++) after.push(i);
-  const before = [];
-  for (let i = cursorLine - 1; i >= docStart; i--) before.push(i);
-  return scan(after) ?? scan(before);
-}
-
 /** Looks up the `x-telo-ref` string carried by the schema node at `yamlPath`
  *  inside `definitionSchema`. Checks both the property node directly and its
  *  peeled `anyOf` / `oneOf` branches, since some library schemas place the
@@ -320,144 +163,84 @@ export function lookupRefConstraint(
   return undefined;
 }
 
+/** Derive a `CompletionCtx` from the AST-resolved cursor (Approach B). The
+ *  structural resolution lives in `resolveNodeAtPosition`; this only maps a
+ *  resolved slot onto the completion the editor should offer. `docs` lets a
+ *  host thread its already-parsed AST; without it we parse locally so this
+ *  stands alone. */
 export function detectContext(
   text: string,
   line: number,
   character: number,
+  docs?: AstDocument[],
 ): CompletionCtx | undefined {
-  const lines = text.split("\n");
-  const currentLine = lines[line] ?? "";
-
-  const { start, end } = findDocBounds(lines, line);
-  const docKind = extractKindFromDoc(lines, start, end);
-
-  // Kind value completion fires ONLY when the cursor sits past the `:` of a
-  // `kind:` line. With the cursor on the key portion (start, middle, or right
-  // before the colon) we fall through to prop-key completion so `kind` itself
-  // can be suggested. Matches both top-level (`kind: …`) and indented forms;
-  // indented form also surfaces the enclosing ref slot for filtering.
-  const kindLineMatch = currentLine.match(/^(\s*)kind:(\s*)(\S*)$/);
-  if (kindLineMatch) {
-    const indent = kindLineMatch[1].length;
-    const valueStart = indent + "kind:".length + kindLineMatch[2].length;
-    if (character >= valueStart) {
-      if (indent === 0) return { type: "kind", valueStartColumn: valueStart };
-      if (docKind) {
-        const yamlPath = buildYamlPath(lines, line, start, indent);
-        return { type: "kind", docKind, yamlPath, valueStartColumn: valueStart };
-      }
+  const resolved = resolveNodeAtPosition(text, docs ?? parseToAst(text), line, character);
+  if (!resolved) return undefined;
+  const { docKind } = resolved;
+
+  if (resolved.slot === "value") {
+    // Inside a CEL body — structural completion does not apply (a future
+    // CEL-completion feature consumes `resolved.cel`).
+    if (resolved.cel) return undefined;
+    const replaceRange = resolved.replaceRange;
+    if (!replaceRange) return undefined;
+    const key = resolved.path[resolved.path.length - 1];
+    const parentPath = resolved.path.slice(0, -1);
+    const prefix = resolved.prefix ?? "";
+
+    if (key === "kind") {
+      if (parentPath.length === 0) return { type: "kind", replaceRange };
+      if (docKind) return { type: "kind", docKind, yamlPath: parentPath, replaceRange };
+      return undefined;
     }
-    // Cursor is on the key portion — fall through to prop-key handling.
-  }
 
-  // Capability value completion: only inside Telo.Definition docs
-  if (/^capability:\s*\S*$/.test(currentLine) && docKind === "Telo.Definition") {
-    return { type: "capability" };
-  }
+    if (key === "capability" && docKind === "Telo.Definition") {
+      return { type: "capability" };
+    }
 
-  // Ref-name value completion: cursor on the value of a `name:` line inside
-  // an object-form ref (sibling `kind:` declares which resource kind we're
-  // referencing). The enclosing parent slot's schema carries the ref
-  // constraint, but we don't need to consult it here — `buildCompletions`
-  // will fall back to filtering by `refKind` regardless of the schema. Doing
-  // so keeps editor autocomplete working even when the registry hasn't fully
-  // resolved the resource's definition.
-  const nameLineMatch = currentLine.match(/^(\s+)name:(\s*)(\S*)$/);
-  if (nameLineMatch && docKind) {
-    const indent = nameLineMatch[1].length;
-    const valueStart = indent + "name:".length + nameLineMatch[2].length;
-    const valuePrefix = nameLineMatch[3];
-    if (character >= valueStart) {
-      const yamlPath = buildYamlPath(lines, line, start, indent);
-      // The yamlPath built here points at the parent slot — for
-      // `connection: { kind: …, name: | }` the path is `["connection"]`.
-      // The sibling `kind:` lives at the same indent as our `name:`, so we
-      // scan the doc bounds for it.
-      const refKind = findSiblingKindValue(lines, start, end, line, indent);
+    // Any `name:` value is a candidate ref target; the sibling `kind:` (when
+    // present) narrows the in-file resource list. Harmless on `metadata.name`,
+    // where no ref constraint resolves and the list is the fallback.
+    if (key === "name" && docKind) {
       return {
         type: "ref-name",
         docKind,
-        yamlPath,
-        refKind,
-        prefix: valuePrefix,
-        valueStartColumn: valueStart,
+        yamlPath: parentPath,
+        refKind: resolved.siblingKind,
+        prefix,
+        replaceRange,
       };
     }
-  }
 
-  if (!docKind) return undefined;
-
-  // Import-source value completion: entries in the `imports:` map on a module
-  // doc. Two shapes are completed against filesystem paths / registry ids:
-  //   scalar shorthand  `  Alias: <src>`     → the entry value IS the source
-  //   object form       `    source: <src>`  → the `source:` under `imports.<Alias>`
-  // Gated on the enclosing path resolving to the `imports:` map so unrelated
-  // `source:` fields (e.g. `Assert.Manifest.source`) never trigger it.
-  if (docKind === "Telo.Application" || docKind === "Telo.Library") {
-    // Require a space after the colon (`key: …`) so a bare object-form header —
-    // `  Tiny:` about to carry a nested `source:`/`variables:` — is treated as a
-    // key position, not an import-source value. A flow-map (`Alias: { … }`) never
-    // matches: `\S*` can't span the spaces inside the braces.
-    const entryMatch = currentLine.match(/^(\s+)([A-Za-z_][\w-]*):(\s+)(\S*)$/);
-    if (entryMatch) {
-      const indent = entryMatch[1].length;
-      const key = entryMatch[2];
-      const valueStartColumn = indent + key.length + 1 + entryMatch[3].length;
-      if (character >= valueStartColumn) {
-        const parentPath = buildYamlPath(lines, line, start, indent);
-        const isScalarEntry = parentPath.length === 1 && parentPath[0] === "imports";
-        const isObjectSource =
-          key === "source" && parentPath.length === 2 && parentPath[0] === "imports";
-        if (isScalarEntry || isObjectSource) {
-          const prefix = currentLine.slice(valueStartColumn, character);
-          return { type: "field-value", docKind, field: "import-source", prefix, valueStartColumn };
-        }
+    // Import-source: the scalar shorthand `imports.<Alias>` or the object-form
+    // `imports.<Alias>.source`. `spaceAfterColon` distinguishes `Console: ` (a
+    // value) from a bare `Tiny:` header about to carry a nested `source:`.
+    if (
+      (docKind === "Telo.Application" || docKind === "Telo.Library") &&
+      resolved.spaceAfterColon
+    ) {
+      const isScalarEntry = parentPath.length === 1 && parentPath[0] === "imports";
+      const isObjectSource =
+        key === "source" && parentPath.length === 2 && parentPath[0] === "imports";
+      if (isScalarEntry || isObjectSource) {
+        return { type: "field-value", docKind, field: "import-source", prefix, replaceRange };
       }
     }
-  }
-
-  const trimmed = currentLine.trim();
 
-  // Trigger when the cursor is on the KEY portion of the line. Three cases:
-  //   1. Blank line / whitespace only — `existingKeys` skip means the user is
-  //      starting a fresh key.
-  //   2. Line has no `:` yet (e.g. `vers`, `version`) — partial key being typed.
-  //   3. Line has `key: value` and the cursor is at or before the colon.
-  //      The line text is preserved so `version|: 1.0.0` keeps suggesting keys
-  //      while `version: |1.0.0` falls through to no completion.
-  const colonIdx = currentLine.indexOf(":");
-  const beforeColon = colonIdx === -1 ? currentLine : currentLine.slice(0, colonIdx);
-  const isKeyLine =
-    trimmed === "" ||
-    (colonIdx === -1 && /^\s*[a-zA-Z_][a-zA-Z0-9_]*$/.test(currentLine)) ||
-    (colonIdx !== -1 &&
-      character <= colonIdx &&
-      /^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*$/.test(beforeColon));
-  if (!isKeyLine) return undefined;
-
-  // Indent resolution: for a whitespace-only line the cursor's column tells
-  // us exactly where the user is about to type — VS Code parks the cursor at
-  // the new auto-indent after Enter, and any deviation (backspace to col 0,
-  // type extra spaces) is intentional. Trusting `character` also lets the
-  // user reach root level (col 0) on a trailing blank line even when the
-  // previous non-blank line was nested.
-  const indent =
-    trimmed === ""
-      ? character
-      : currentLine.length - currentLine.trimStart().length;
-
-  if (indent === 0) {
-    return {
-      type: "prop-key",
-      docKind,
-      yamlPath: [],
-      existingKeys: extractRootKeys(lines, start, end, line),
-    };
+    return undefined;
   }
 
-  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, line);
-  return { type: "prop-key", docKind, yamlPath, existingKeys };
+  // Key position (existing key, blank line, or trailing indent). Complete
+  // against the nearest enclosing inline resource's schema (or the root
+  // resource), with the path made relative to it — so a prop key inside
+  // `mount: { kind: Crud.Resource, … }` offers Crud.Resource's fields, not the
+  // outer ref slot's.
+  const scopeKind = resolved.resourceKind ?? docKind;
+  if (!scopeKind) return undefined;
+  return {
+    type: "prop-key",
+    docKind: scopeKind,
+    yamlPath: resolved.path.slice(resolved.resourceDepth ?? 0),
+    existingKeys: resolved.existingKeys ?? new Set<string>(),
+  };
 }

package/src/completions/import-source.ts

@@ -1,4 +1,4 @@
-import type { CompletionResult, IdeEnvironmentAdapter } from "../types.js";
+import type { CompletionResult, IdeEnvironmentAdapter, ReplaceRange } from "../types.js";
 
 /** Maximum ref hits to surface in a single completion request. Keeps the
  *  popover scannable when a broad `q=` query matches many registered refs
@@ -26,13 +26,13 @@ const PATH_PROBE_LIMIT = 50;
  * search below, whose query is the whole typed prefix — so the hub fuzzy-matches
  * `oci://ghcr.io/aws/telo-s3` as readily as a bare `s3`.
  *
- * `valueStartColumn` is forwarded onto every result so the host can replace
- * the whole typed value, not just the trailing word (Monaco / VSCode word
- * boundaries don't cross `/` or `@`).
+ * `replaceRange` is forwarded onto every result so the host replaces the whole
+ * value, not just the trailing word (Monaco / VSCode word boundaries don't
+ * cross `/` or `@`).
  */
 export async function importSourceCompletions(
   prefix: string,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
   adapter: IdeEnvironmentAdapter | undefined,
 ): Promise<CompletionResult[]> {
   if (!adapter) return [];
@@ -48,22 +48,22 @@ export async function importSourceCompletions(
   const isRelativeShape =
     prefix === "" || prefix.startsWith(".") || prefix.startsWith("/");
   if (isRelativeShape) {
-    return relativePathCompletions(prefix, valueStartColumn, adapter);
+    return relativePathCompletions(prefix, replaceRange, adapter);
   }
 
   // The version (or `@sha256:` digest) is the trailing `@`-segment, so split on
   // the LAST `@` — a digest-pinned ref keeps everything before it as the ref.
   const atIdx = prefix.lastIndexOf("@");
   if (atIdx > 0) {
-    return versionCompletions(prefix, atIdx, valueStartColumn, adapter);
+    return versionCompletions(prefix, atIdx, replaceRange, adapter);
   }
 
-  return refSearchCompletions(prefix, valueStartColumn, adapter);
+  return refSearchCompletions(prefix, replaceRange, adapter);
 }
 
 async function relativePathCompletions(
   prefix: string,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
   adapter: IdeEnvironmentAdapter,
 ): Promise<CompletionResult[]> {
   // Empty prefix → seed `./` and `../` so the user gets traction; otherwise
@@ -76,14 +76,14 @@ async function relativePathCompletions(
         kind: "folder",
         insertText: "./",
         sortText: "0_./",
-        replaceFromColumn: valueStartColumn,
+        replaceRange,
       },
       {
         label: "../",
         kind: "folder",
         insertText: "../",
         sortText: "0_../",
-        replaceFromColumn: valueStartColumn,
+        replaceRange,
       },
     ];
   }
@@ -118,7 +118,7 @@ async function relativePathCompletions(
         detail: isModule ? "telo module" : "folder",
         insertText: fullPath,
         filterText: fullPath,
-        replaceFromColumn: valueStartColumn,
+        replaceRange,
         // Modules sort above plain folders so they surface first when the user
         // is browsing a `modules/` tree mixed with non-Telo siblings.
         sortText: isModule ? `0_${name}` : `1_${name}`,
@@ -129,7 +129,7 @@ async function relativePathCompletions(
 
 async function refSearchCompletions(
   prefix: string,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
   adapter: IdeEnvironmentAdapter,
 ): Promise<CompletionResult[]> {
   // The whole typed prefix is the fuzzy query — the hub matches it as a
@@ -154,7 +154,7 @@ async function refSearchCompletions(
       documentation: m.description ? m.ref : undefined,
       insertText: id,
       filterText: id,
-      replaceFromColumn: valueStartColumn,
+      replaceRange,
     };
   });
 }
@@ -173,7 +173,7 @@ function refDisplayName(ref: string): string {
 async function versionCompletions(
   prefix: string,
   atIdx: number,
-  valueStartColumn: number,
+  replaceRange: ReplaceRange,
   adapter: IdeEnvironmentAdapter,
 ): Promise<CompletionResult[]> {
   const ref = prefix.slice(0, atIdx);
@@ -195,7 +195,7 @@ async function versionCompletions(
       detail: idx === 0 ? "latest" : undefined,
       insertText: id,
       filterText: id,
-      replaceFromColumn: valueStartColumn,
+      replaceRange,
       // Preserve the hub's ordering (newest first) so the latest version is
       // suggested at the top regardless of lexical comparison.
       sortText: String(idx).padStart(4, "0"),