@intentius/chant-lexicon-terraform 0.57.0

package/src/lsp/completions.test.ts

@@ -0,0 +1,120 @@
+/**
+ * LSP completions tests (#2088). Root-name completion needs a reachable
+ * `chant.config.*`, so those cases write one to a temp directory rather than
+ * mocking `./context` — the point of the feature is reading a real file.
+ */
+
+import { describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { CompletionContext } from "@intentius/chant/lsp/types";
+import { completions } from "./completions";
+
+function ctx(overrides: Partial<CompletionContext>): CompletionContext {
+  return {
+    uri: "untitled:Untitled-1",
+    content: "",
+    position: { line: 0, character: 0 },
+    wordAtCursor: "",
+    linePrefix: "",
+    ...overrides,
+  };
+}
+
+describe("LSP completions", () => {
+  it("returns an array for an empty context", () => {
+    expect(Array.isArray(completions(ctx({})))).toBe(true);
+  });
+
+  it("completes root names inside a builder's positional root argument, from a reachable config", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      writeFileSync(
+        join(dir, "chant.config.ts"),
+        `export default { terraform: { roots: { app: { dir: "./terraform" }, db: { dir: "./db" } } } };`,
+      );
+      const uri = pathToFileURL(join(dir, "infra.op.ts")).toString();
+      const linePrefix = 'terraformPlan("';
+      const items = completions(ctx({ uri, linePrefix }));
+      expect(items.map((i) => i.label).sort()).toEqual(["app", "db"]);
+      expect(items[0].kind).toBe("value");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("completes root names inside a named `root:` field", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      writeFileSync(join(dir, "chant.config.ts"), `export default { terraform: { roots: { app: { dir: "./tf" } } } };`);
+      const uri = pathToFileURL(join(dir, "infra.op.ts")).toString();
+      const items = completions(ctx({ uri, linePrefix: '  root: "a' }));
+      expect(items.map((i) => i.label)).toEqual(["app"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("filters root names by the prefix already typed", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      writeFileSync(
+        join(dir, "chant.config.ts"),
+        `export default { terraform: { roots: { app: { dir: "./a" }, api: { dir: "./b" }, db: { dir: "./c" } } } };`,
+      );
+      const uri = pathToFileURL(join(dir, "infra.op.ts")).toString();
+      const items = completions(ctx({ uri, linePrefix: 'terraformApply("ap' }));
+      expect(items.map((i) => i.label).sort()).toEqual(["api", "app"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("offers no root names when no chant.config.* is reachable, rather than fabricating any", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      const uri = pathToFileURL(join(dir, "infra.op.ts")).toString();
+      const items = completions(ctx({ uri, linePrefix: 'terraformPlan("' }));
+      expect(items).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("completes TerraformApplyOp's own config keys inside its argument object", () => {
+    const content = 'export const { op } = TerraformApplyOp({\n  name: "app-apply",\n  ';
+    const items = completions(
+      ctx({ content, position: { line: 2, character: 2 }, uri: "untitled:Untitled-1" }),
+    );
+    const labels = items.map((i) => i.label);
+    expect(labels).toContain("gate");
+    expect(labels).toContain("compensate");
+    expect(labels).toContain("taskQueue");
+  });
+
+  it("completes a builder's own opts keys inside its second argument", () => {
+    const content = 'terraformPlan("app", {\n  ';
+    const items = completions(ctx({ content, position: { line: 1, character: 2 } }));
+    expect(items.map((i) => i.label)).toEqual(expect.arrayContaining(["planFile", "destroy", "cwd", "id"]));
+  });
+
+  it("completes root-entry keys inside chant.config.ts's terraform.roots.<name>", () => {
+    const content = "export default {\n  terraform: {\n    roots: {\n      app: {\n        ";
+    const items = completions(ctx({ content, position: { line: 4, character: 8 } }));
+    expect(items.map((i) => i.label).sort()).toEqual(["backendConfig", "dir", "varFiles", "workspace"]);
+  });
+
+  it("completes the terraform namespace's own top-level keys", () => {
+    const content = "export default {\n  terraform: {\n    ";
+    const items = completions(ctx({ content, position: { line: 1, character: 4 } }));
+    expect(items.map((i) => i.label).sort()).toEqual(["binary", "roots"]);
+  });
+
+  it("completes compensate's own key", () => {
+    const content = 'TerraformApplyOp({\n  compensate: {\n    ';
+    const items = completions(ctx({ content, position: { line: 2, character: 4 } }));
+    expect(items.map((i) => i.label)).toEqual(["command"]);
+  });
+});

package/src/lsp/completions.ts

@@ -0,0 +1,101 @@
+/**
+ * LSP completions for the terraform lexicon (#2088).
+ *
+ * k3s's shape (a generated `LexiconIndex` over typed resource classes) does
+ * not fit here: terraform's declarables are lightweight per-HCL-block
+ * entities `buildRoots()` produces at build time, not authored TypeScript
+ * types — there is nothing to generate a completion index from. What an
+ * ops-only lexicon can honestly complete is the surface an `*.op.ts` author
+ * actually types:
+ *
+ *   - `terraform.roots` names, read from the reachable `chant.config.*` (see
+ *     `./context.ts`) — completed inside a root-name position, e.g.
+ *     `terraformPlan("` or `root: "`.
+ *   - the composite/builder option keys (`./option-keys.ts`) — completed
+ *     inside the relevant call's options object.
+ *
+ * Root names complete only when a `chant.config.*` is reachable from the
+ * document's own `uri` and declares at least one; there is no synchronous,
+ * safe way to evaluate `chant.config.ts` (project-authored code) from inside
+ * a completion request, so an unreachable config yields no root-name
+ * completions rather than a guessed one. Option keys need no config at all
+ * and complete unconditionally.
+ */
+
+import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
+import { contentUpToCursor, enclosingCallName, enclosingKeyPath, innermostObjectKey, resolveRootsForUri } from "./context";
+import { APPLY_OP_KEYS, BUILDER_OPTS_BY_CALL, COMPENSATE_KEYS, CONFIG_NAMESPACE_KEYS, ROOT_ENTRY_KEYS, type OptionKey } from "./option-keys";
+
+/** `terraformPlan("` / `terraformApply(` — the first positional string arg, which every builder types as `root`. */
+const ROOT_POSITIONAL_ARG = new RegExp(`\\b(${Object.keys(BUILDER_OPTS_BY_CALL).join("|")})\\(\\s*["'](\\w*)$`);
+
+/** `root: "` — the named field, in `TerraformApplyOp({ ... })` or a raw `activity("terraformPlan", { root: "..." })`. */
+const ROOT_NAMED_FIELD = /\broot\s*:\s*["'](\w*)$/;
+
+function keyCompletions(keys: OptionKey[], prefix: string): CompletionItem[] {
+  const lower = prefix.toLowerCase();
+  return keys
+    .filter((k) => !lower || k.key.toLowerCase().startsWith(lower))
+    .map((k) => ({
+      label: k.key,
+      insertText: k.key,
+      kind: "property" as const,
+      documentation: k.detail,
+    }));
+}
+
+function rootCompletions(uri: string, prefix: string): CompletionItem[] {
+  const roots = resolveRootsForUri(uri);
+  if (!roots) return [];
+  const lower = prefix.toLowerCase();
+  return Object.entries(roots)
+    .filter(([name]) => !lower || name.toLowerCase().startsWith(lower))
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([name, root]) => ({
+      label: name,
+      insertText: name,
+      kind: "value" as const,
+      detail: root.dir,
+      documentation: [
+        root.dir ? `dir: ${root.dir}` : undefined,
+        root.workspace ? `workspace: ${root.workspace}` : undefined,
+        root.varFiles?.length ? `varFiles: ${root.varFiles.join(", ")}` : undefined,
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join("\n"),
+    }));
+}
+
+export function completions(ctx: CompletionContext): CompletionItem[] {
+  const linePrefix = ctx.linePrefix ?? "";
+
+  const positional = ROOT_POSITIONAL_ARG.exec(linePrefix);
+  if (positional) return rootCompletions(ctx.uri, positional[2]);
+
+  const namedField = ROOT_NAMED_FIELD.exec(linePrefix);
+  if (namedField) return rootCompletions(ctx.uri, namedField[1]);
+
+  const upToCursor = contentUpToCursor(ctx.content ?? "", ctx.position?.line ?? 0);
+  const prefix = ctx.wordAtCursor ?? "";
+
+  const call = enclosingCallName(upToCursor);
+  if (call === "TerraformApplyOp") return keyCompletions(APPLY_OP_KEYS, prefix);
+  if (call && call in BUILDER_OPTS_BY_CALL) return keyCompletions(BUILDER_OPTS_BY_CALL[call], prefix);
+
+  // `compensate: { <cursor>` — checked independent of the call chain above,
+  // since `compensate` itself sits inside `TerraformApplyOp({ ... })`'s own
+  // argument object, which `enclosingKeyPath` below refuses to walk through.
+  if (innermostObjectKey(upToCursor) === "compensate") return keyCompletions(COMPENSATE_KEYS, prefix);
+
+  // The remaining contexts are all plain nested object literals with no call
+  // in the chain — `chant.config.ts`'s own `terraform: { ... }` namespace.
+  const path = enclosingKeyPath(upToCursor);
+  if (path) {
+    const last = path[path.length - 1];
+    const parent = path[path.length - 2];
+    if (parent === "roots") return keyCompletions(ROOT_ENTRY_KEYS, prefix);
+    if (last === "terraform") return keyCompletions(CONFIG_NAMESPACE_KEYS, prefix);
+  }
+
+  return [];
+}

package/src/lsp/context.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Tests for the shared LSP context helpers (#2088): parsing `terraform.roots`
+ * out of a `chant.config.ts`/`.json`'s raw text (never executing it), and the
+ * call/field detectors `completions.ts` uses to place the cursor.
+ */
+
+import { describe, expect, it } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  contentUpToCursor,
+  enclosingCallName,
+  enclosingKeyPath,
+  innermostObjectKey,
+  parseTerraformRoots,
+  resolveRootsForUri,
+} from "./context";
+
+describe("parseTerraformRoots (.ts)", () => {
+  it("extracts dir, workspace and varFiles per root", () => {
+    const text = `
+import type { ChantConfig } from "@intentius/chant/config";
+import "@intentius/chant-lexicon-terraform";
+
+export default {
+  lexicons: ["terraform"],
+  terraform: {
+    binary: "tofu",
+    roots: {
+      app: { dir: "./terraform/app", workspace: "prod", varFiles: ["prod.tfvars", "shared.tfvars"] },
+      db: {
+        dir: "./terraform/db",
+      },
+    },
+  },
+} satisfies ChantConfig;
+`;
+    const roots = parseTerraformRoots(text, "ts");
+    expect(roots).toEqual({
+      app: { dir: "./terraform/app", workspace: "prod", varFiles: ["prod.tfvars", "shared.tfvars"] },
+      db: { dir: "./terraform/db", workspace: undefined, varFiles: undefined },
+    });
+  });
+
+  it("returns undefined when the config declares no terraform namespace", () => {
+    expect(parseTerraformRoots(`export default { lexicons: ["k3s"] };`, "ts")).toBeUndefined();
+  });
+
+  it("returns undefined when terraform.roots is empty", () => {
+    expect(parseTerraformRoots(`export default { terraform: { roots: {} } };`, "ts")).toBeUndefined();
+  });
+});
+
+describe("parseTerraformRoots (.json)", () => {
+  it("reads a plain object, no brace-matching needed", () => {
+    const json = JSON.stringify({ terraform: { roots: { app: { dir: "./tf" } } } });
+    expect(parseTerraformRoots(json, "json")).toEqual({
+      app: { dir: "./tf", workspace: undefined, varFiles: undefined },
+    });
+  });
+
+  it("returns undefined for invalid JSON rather than throwing", () => {
+    expect(parseTerraformRoots("{ not json", "json")).toBeUndefined();
+  });
+});
+
+describe("resolveRootsForUri", () => {
+  it("walks up from the document's directory to the nearest chant.config.ts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      writeFileSync(
+        join(dir, "chant.config.ts"),
+        `export default { terraform: { roots: { app: { dir: "./tf" } } } };`,
+      );
+      const nested = join(dir, "src");
+      const uri = pathToFileURL(join(nested, "infra.op.ts")).toString();
+      expect(resolveRootsForUri(uri)).toEqual({ app: { dir: "./tf", workspace: undefined, varFiles: undefined } });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns undefined for a non-file:// uri", () => {
+    expect(resolveRootsForUri("untitled:Untitled-1")).toBeUndefined();
+  });
+
+  it("returns undefined when no chant.config.* is reachable", () => {
+    const dir = mkdtempSync(join(tmpdir(), "chant-terraform-lsp-"));
+    try {
+      const uri = pathToFileURL(join(dir, "infra.op.ts")).toString();
+      expect(resolveRootsForUri(uri)).toBeUndefined();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("enclosingCallName", () => {
+  it("finds the call whose sole argument object holds the cursor", () => {
+    const text = 'export const { op } = TerraformApplyOp({\n  name: "x",\n  ';
+    expect(enclosingCallName(text)).toBe("TerraformApplyOp");
+  });
+
+  it("finds the call when the object is a later positional argument", () => {
+    const text = 'terraformPlan("app", {\n  ';
+    expect(enclosingCallName(text)).toBe("terraformPlan");
+  });
+
+  it("returns undefined outside any call", () => {
+    expect(enclosingCallName("const x = {\n  ")).toBeUndefined();
+  });
+
+  it("returns undefined when the cursor is not inside an object literal at all", () => {
+    expect(enclosingCallName("terraformPlan(")).toBeUndefined();
+  });
+});
+
+describe("enclosingKeyPath", () => {
+  it("names the chain of enclosing object keys", () => {
+    const text = "export default {\n  terraform: {\n    roots: {\n      app: {\n        ";
+    expect(enclosingKeyPath(text)).toEqual(["terraform", "roots", "app"]);
+  });
+
+  it("returns undefined once a call sits in the chain", () => {
+    const text = "foo({\n  bar: {\n    ";
+    expect(enclosingKeyPath(text)).toBeUndefined();
+  });
+
+  it("contributes nothing for the top-level object literal, which no key precedes", () => {
+    const text = "export default {\n  ";
+    expect(enclosingKeyPath(text)).toEqual([]);
+  });
+});
+
+describe("innermostObjectKey", () => {
+  it("names the immediate enclosing key even when a call sits further out", () => {
+    const text = "TerraformApplyOp({\n  compensate: {\n    ";
+    expect(innermostObjectKey(text)).toBe("compensate");
+  });
+
+  it("returns undefined when the cursor is not inside any object literal", () => {
+    expect(innermostObjectKey("terraformPlan(")).toBeUndefined();
+  });
+});
+
+describe("contentUpToCursor", () => {
+  it("joins every line through the cursor's own line", () => {
+    expect(contentUpToCursor("a\nb\nc", 1)).toBe("a\nb");
+  });
+});