@telorun/ide-support 0.4.2 → 0.4.5

package/src/completions/prop-keys.ts

@@ -2,6 +2,20 @@ import type { AnalysisRegistry } from "@telorun/analyzer";
 import type { CompletionResult } from "../types.js";
 import { navigateSchema } from "./detect-context.js";
 
+/** Kernel-implicit fields. Every Telo resource declares its `kind` and a
+ *  `metadata` object; the analyzer's schema validator injects them when
+ *  the definition uses `additionalProperties: false`. Completion has the
+ *  same need — domain-specific schemas (`Http.Api`, `Sql.Query`, …) don't
+ *  enumerate these in their own `properties`, so without an explicit fallback
+ *  the user can't autocomplete `kind:` or `metadata:` on those resources. */
+const ROOT_IMPLICIT_PROPS: Record<string, Record<string, any>> = {
+  kind: { type: "string", description: "The fully-qualified resource kind." },
+  metadata: {
+    type: "object",
+    description: "Resource metadata (name, namespace, version).",
+  },
+};
+
 export function propKeyCompletions(
   kind: string,
   yamlPath: string[],
@@ -11,24 +25,46 @@ export function propKeyCompletions(
   if (!registry) return [];
 
   const definition = registry.resolveDefinition(kind);
-  if (!definition?.schema) return [];
+  if (!definition?.schema) {
+    // Unknown kind (often: an unloaded import). At root level, still surface
+    // the universal `kind` / `metadata` keys so completion isn't dead when
+    // the registry hasn't resolved the resource type yet.
+    if (yamlPath.length === 0) {
+      return buildItems(ROOT_IMPLICIT_PROPS, existingKeys, new Set<string>());
+    }
+    return [];
+  }
 
   const targetSchema = yamlPath.length === 0
     ? (definition.schema as Record<string, any>)
     : navigateSchema(definition.schema as Record<string, any>, yamlPath);
 
-  if (!targetSchema?.properties) return [];
+  if (!targetSchema?.properties) {
+    if (yamlPath.length === 0) {
+      return buildItems(ROOT_IMPLICIT_PROPS, existingKeys, new Set<string>());
+    }
+    return [];
+  }
 
   const required = new Set<string>(
     Array.isArray(targetSchema.required) ? targetSchema.required : [],
   );
-  const items: CompletionResult[] = [];
+  const properties =
+    yamlPath.length === 0
+      ? { ...ROOT_IMPLICIT_PROPS, ...(targetSchema.properties as Record<string, any>) }
+      : (targetSchema.properties as Record<string, any>);
 
-  for (const [prop, propSchema] of Object.entries(
-    targetSchema.properties as Record<string, any>,
-  )) {
+  return buildItems(properties, existingKeys, required);
+}
+
+function buildItems(
+  properties: Record<string, any>,
+  existingKeys: Set<string>,
+  required: Set<string>,
+): CompletionResult[] {
+  const items: CompletionResult[] = [];
+  for (const [prop, propSchema] of Object.entries(properties)) {
     if (existingKeys.has(prop)) continue;
-    if (yamlPath.length === 0 && (prop === "kind" || prop === "metadata")) continue;
 
     const item: CompletionResult = {
       label: prop,

package/src/diagnostics/range-resolver.ts

@@ -9,16 +9,28 @@ const ZERO_RANGE: Range = {
 /** 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. */
+ *    2. `positionIndex.get(d.data.path)` for a direct hit (covers diagnostics
+ *       that target an existing value, e.g. wrong type, enum violation).
+ *    3. If the leaf is missing (e.g. "missing required property" — `.type`
+ *       isn't in the YAML yet), walk one segment up at a time and squiggle
+ *       just the parent's key identifier (`@key:<parent>`), not the parent's
+ *       full value block. Keeps the squiggle scoped to the incomplete entry
+ *       instead of spreading across every line of the surrounding map.
+ *    4. Whole-line span at `sourceLine` when known.
+ *    5. `(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;
+    const direct = ctx.positionIndex.get(fieldPath);
+    if (direct) return direct;
+    for (const parent of parentPaths(fieldPath).slice(1)) {
+      const keyRange = ctx.positionIndex.get(`@key:${parent}`);
+      if (keyRange) return keyRange;
+      const valueRange = ctx.positionIndex.get(parent);
+      if (valueRange) return valueRange;
+    }
   }
 
   if (ctx.sourceLine !== undefined) {
@@ -30,3 +42,22 @@ export function resolveRange(d: AnalysisDiagnostic, ctx: DiagnosticContext): Ran
 
   return ZERO_RANGE;
 }
+
+/** Yield `path`, then progressively shorter parents formed by stripping
+ *  trailing dotted segments and array index suffixes. For
+ *  `"secrets.openaiApiKey.type"` → `["secrets.openaiApiKey.type",
+ *  "secrets.openaiApiKey", "secrets"]`. For `"routes[0].handler"` →
+ *  `["routes[0].handler", "routes[0]", "routes"]`. */
+function parentPaths(path: string): string[] {
+  const out: string[] = [];
+  let cur = path;
+  while (cur.length > 0) {
+    out.push(cur);
+    const lastDot = cur.lastIndexOf(".");
+    const lastBracket = cur.lastIndexOf("[");
+    const cut = Math.max(lastDot, lastBracket);
+    if (cut <= 0) break;
+    cur = cur.slice(0, cut);
+  }
+  return out;
+}