@checkstack/ui 1.10.0 → 1.12.0

package/src/components/CodeEditor/bracketKeyGroups.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from "bun:test";
+import { extractBracketKeyGroups } from "./bracketKeyGroups";
+
+describe("extractBracketKeyGroups", () => {
+  it("returns [] when there is no `declare const context`", () => {
+    expect(
+      extractBracketKeyGroups({ typeDefinitions: "interface Foo { x: string }" }),
+    ).toEqual([]);
+  });
+
+  it("returns [] when no property keys are non-identifiers", () => {
+    const typeDefinitions = `declare const context: {
+      event: { payload: { repository: string; count: number } };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([]);
+  });
+
+  it("extracts a non-identifier key and its dotted parent path", () => {
+    const typeDefinitions = `declare const context: {
+      artifacts: {
+        "integration-jira.issue": { key: string; summary: string };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      { objectExpression: "context.artifacts", keys: ["integration-jira.issue"] },
+    ]);
+  });
+
+  it("groups multiple non-identifier keys under the same parent", () => {
+    const typeDefinitions = `declare const context: {
+      artifacts: {
+        "integration-jira.issue": { key: string };
+        "integration-github.pr": { number: number };
+        valid: { ok: boolean };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      {
+        objectExpression: "context.artifacts",
+        keys: ["integration-jira.issue", "integration-github.pr"],
+      },
+    ]);
+  });
+
+  it("does NOT treat string-literal union *values* as keys", () => {
+    const typeDefinitions = `declare const context: {
+      artifacts: {
+        "a-b": { status: "open" | "closed"; url: "https://x" };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      { objectExpression: "context.artifacts", keys: ["a-b"] },
+    ]);
+  });
+
+  it("ignores JSDoc and line comments (including braces inside them)", () => {
+    const typeDefinitions = `declare const context: {
+      /** an object like { not: a real brace } */
+      artifacts: {
+        // "comment-key": should be ignored
+        "real-key": { x: string };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      { objectExpression: "context.artifacts", keys: ["real-key"] },
+    ]);
+  });
+
+  it("handles `readonly` and optional `?` modifiers and deeper paths", () => {
+    const typeDefinitions = `declare const context: {
+      readonly event: {
+        readonly meta?: {
+          "x-trace.id": { v: string };
+        };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      { objectExpression: "context.event.meta", keys: ["x-trace.id"] },
+    ]);
+  });
+
+  it("skips non-identifier keys nested under a non-identifier parent", () => {
+    // `context["a-b"]` is not a dotted objectExpression, so the inner key has
+    // no addressable parent and must be skipped.
+    const typeDefinitions = `declare const context: {
+      "a-b": {
+        "c-d": { x: string };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      { objectExpression: "context", keys: ["a-b"] },
+    ]);
+  });
+
+  it("extracts OPTIONAL quoted keys (`\"key\"?:`) - the real generated shape", () => {
+    // Mirrors generateAutomationContextTypes output for upstream artifacts:
+    // `readonly artifacts: { readonly "integration-jira.issue"?: {...}; }`.
+    const typeDefinitions = `declare const context: {
+      readonly artifacts: {
+        readonly "integration-jira.issue"?: { key: string; url?: string };
+        readonly "integration-github.pr"?: { number: number };
+      };
+    };`;
+    expect(extractBracketKeyGroups({ typeDefinitions })).toEqual([
+      {
+        objectExpression: "context.artifacts",
+        keys: ["integration-jira.issue", "integration-github.pr"],
+      },
+    ]);
+  });
+
+  it("respects a custom root name", () => {
+    const typeDefinitions = `declare const scope: {
+      vars: { "weird key": { x: string } };
+    };`;
+    expect(
+      extractBracketKeyGroups({ typeDefinitions, rootName: "scope" }),
+    ).toEqual([{ objectExpression: "scope.vars", keys: ["weird key"] }]);
+  });
+});

package/src/components/CodeEditor/bracketKeyGroups.ts

@@ -0,0 +1,205 @@
+// Stage 2b (monaco-editor -> @typefox/monaco-editor-react migration).
+//
+// The standalone TS worker calls `getCompletionsAtPosition` with no options
+// (tsWorker.js: `getCompletionsAtPosition(fileName, position, void 0)`), so it
+// never surfaces object members whose keys are not valid JS identifiers (e.g.
+// artifact ids like `integration-jira.issue`). The built-in SuggestAdapter also
+// hardcodes `insertText: entry.name` and can't be overridden, so a custom TS
+// worker is not viable. Instead we register our own completion provider that
+// offers those keys as `["key"]` bracket completions.
+//
+// To stay TYPE-DRIVEN (and avoid threading a separate `dottedKeyCompletions`
+// prop), this module derives the groups straight from the injected
+// `context.d.ts`: it finds object members whose property name is a quoted,
+// non-identifier string and reports the dotted access path to their parent
+// object plus the list of such keys.
+
+/** A parent object plus the non-identifier keys reachable under it. */
+export interface BracketKeyGroup {
+  /** Member-access expression preceding the dot, e.g. `context.artifacts`. */
+  objectExpression: string;
+  /** Keys to offer; each is inserted as `["<key>"]`. */
+  keys: string[];
+}
+
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+
+const isIdentifier = (name: string): boolean => IDENTIFIER_RE.test(name);
+
+const isWhitespace = (ch: string): boolean =>
+  ch === " " || ch === "\t" || ch === "\n" || ch === "\r";
+
+/**
+ * Extract bracket-notation completion groups from generated TS type
+ * definitions. Walks the `declare const <rootName>: { ... }` object literal,
+ * tracking the dotted path as it descends, and records every property whose
+ * name is a quoted non-identifier string.
+ *
+ * The walk is a small purpose-built scanner (not a full TS parser): it is only
+ * ever fed our own generated `context.d.ts`, whose shape is a plain nested
+ * object type. It correctly ignores string-literal type *values* (e.g.
+ * `status: "open" | "closed"`), JSDoc/line comments, and the `readonly` /
+ * optional (`?`) modifiers. Keys nested under a non-identifier parent are
+ * skipped because no dotted `objectExpression` can address them.
+ */
+export const extractBracketKeyGroups = ({
+  typeDefinitions,
+  rootName = "context",
+}: {
+  typeDefinitions: string;
+  rootName?: string;
+}): BracketKeyGroup[] => {
+  const src = typeDefinitions;
+  // Locate `declare const <rootName>` then the opening `{` of its type.
+  const declMatch = new RegExp(
+    String.raw`declare\s+const\s+${rootName}\b`,
+  ).exec(src);
+  if (!declMatch) {
+    return [];
+  }
+  let i = src.indexOf("{", declMatch.index + declMatch[0].length);
+  if (i === -1) {
+    return [];
+  }
+
+  // Insertion-ordered accumulation so output is stable for tests/snapshots.
+  const groups = new Map<string, string[]>();
+  const addKey = (objectExpression: string, key: string): void => {
+    const existing = groups.get(objectExpression);
+    if (existing) {
+      if (!existing.includes(key)) {
+        existing.push(key);
+      }
+    } else {
+      groups.set(objectExpression, [key]);
+    }
+  };
+
+  // path[k] / dottable[k] describe the object open at brace depth k+1.
+  const path: string[] = [rootName];
+  const dottable: boolean[] = [true];
+  let depth = 1; // we consume the root `{` below
+  i += 1; // step past the root object's opening brace
+
+  // The property name most recently parsed, awaiting its value. Used to label
+  // the object we descend into on the next `{`.
+  let pendingName: { value: string; identifier: boolean } | null = null;
+
+  const peekNonWs = (from: number): number => {
+    let j = from;
+    while (j < src.length && isWhitespace(src[j] ?? "")) {
+      j += 1;
+    }
+    return j;
+  };
+
+  while (i < src.length && depth > 0) {
+    const ch = src[i] ?? "";
+
+    // Comments.
+    if (ch === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      i = end === -1 ? src.length : end + 2;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "/") {
+      const nl = src.indexOf("\n", i + 2);
+      i = nl === -1 ? src.length : nl + 1;
+      continue;
+    }
+
+    if (isWhitespace(ch)) {
+      i += 1;
+      continue;
+    }
+
+    // String token: either a property name (if followed by `:`) or a
+    // type-position literal (e.g. a union member) which we ignore.
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let j = i + 1;
+      let str = "";
+      while (j < src.length && src[j] !== quote) {
+        if (src[j] === "\\") {
+          str += src[j + 1] ?? "";
+          j += 2;
+          continue;
+        }
+        str += src[j];
+        j += 1;
+      }
+      const afterStr = j + 1; // past closing quote
+      // A quoted property name may be optional: `"key"?: ...` (this is exactly
+      // how generated artifact keys look, e.g. `"integration-jira.issue"?:`).
+      let colon = peekNonWs(afterStr);
+      if (src[colon] === "?") {
+        colon = peekNonWs(colon + 1);
+      }
+      if (src[colon] === ":") {
+        // Quoted property name. Record under the current object when every
+        // ancestor segment is dot-addressable.
+        if (dottable.every(Boolean) && !isIdentifier(str)) {
+          addKey(path.join("."), str);
+        }
+        pendingName = { value: str, identifier: isIdentifier(str) };
+        i = colon + 1;
+      } else {
+        // Type-position string literal - not a key.
+        i = afterStr;
+      }
+      continue;
+    }
+
+    // Identifier: a property name (if followed by `:`, allowing an optional
+    // `?`) or a type keyword / modifier we skip.
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i;
+      while (j < src.length && /[\w$]/.test(src[j] ?? "")) {
+        j += 1;
+      }
+      const word = src.slice(i, j);
+      let after = peekNonWs(j);
+      if (src[after] === "?") {
+        after = peekNonWs(after + 1);
+      }
+      if (src[after] === ":") {
+        pendingName = { value: word, identifier: true };
+        i = after + 1;
+      } else {
+        // `readonly`, `string`, `interface`, etc. - not a key for us.
+        i = j;
+      }
+      continue;
+    }
+
+    if (ch === "{") {
+      depth += 1;
+      path.push(pendingName?.value ?? "");
+      dottable.push(pendingName?.identifier ?? false);
+      pendingName = null;
+      i += 1;
+      continue;
+    }
+
+    if (ch === "}") {
+      depth -= 1;
+      path.pop();
+      dottable.pop();
+      pendingName = null;
+      i += 1;
+      continue;
+    }
+
+    // End of a property's value (e.g. `: string;`) - the pending name had a
+    // non-object type, so it never labels a descent.
+    if (ch === ";" || ch === ",") {
+      pendingName = null;
+    }
+    i += 1;
+  }
+
+  return [...groups].map(([objectExpression, keys]) => ({
+    objectExpression,
+    keys,
+  }));
+};

package/src/components/CodeEditor/generateTypeDefinitions.ts

@@ -89,10 +89,10 @@ declare const context: {
     `);
   }
 
-  // We deliberately don't redeclare `console`, `fetch`, the Node stdlib,
-  // or the Bun globals here — MonacoEditor mounts the bundled upstream
-  // `@types/node` + `bun-types` declarations into Monaco's virtual
-  // filesystem via `ensureMonacoStdlib`, so all of that is already in scope.
+  // We deliberately don't redeclare `console`, `fetch`, the Node stdlib, or
+  // the Bun globals here: the editor mounts the bundled upstream `@types/node`
+  // + `bun-types` declarations into the TypeScript service, so all of that is
+  // already in scope.
   return lines.join("\n");
 }
 

package/src/components/CodeEditor/generated/builtin-modules.json

@@ -0,0 +1 @@
+["assert","assert/strict","async_hooks","buffer","bun","bun:bundle","bun:ffi","bun:jsc","bun:sqlite","bun:test","child_process","cluster","console","constants","crypto","dgram","diagnostics_channel","dns","dns/promises","domain","events","fs","fs/promises","http","http2","https","inspector","inspector/promises","module","net","node:assert","node:assert/strict","node:async_hooks","node:buffer","node:child_process","node:cluster","node:console","node:constants","node:crypto","node:dgram","node:diagnostics_channel","node:dns","node:dns/promises","node:domain","node:events","node:fs","node:fs/promises","node:http","node:http2","node:https","node:inspector","node:inspector/promises","node:module","node:net","node:os","node:path","node:path/posix","node:path/win32","node:perf_hooks","node:process","node:punycode","node:querystring","node:readline","node:readline/promises","node:repl","node:sea","node:stream","node:stream/consumers","node:stream/promises","node:stream/web","node:string_decoder","node:test","node:test/reporters","node:timers","node:timers/promises","node:tls","node:trace_events","node:tty","node:url","node:util","node:util/types","node:v8","node:vm","node:wasi","node:worker_threads","node:zlib","os","path","path/posix","path/win32","perf_hooks","process","punycode","querystring","readline","readline/promises","repl","stream","stream/consumers","stream/promises","stream/web","string_decoder","timers","timers/promises","tls","trace_events","tty","url","util","util/types","v8","vm","wasi","worker_threads","zlib"]

package/src/components/CodeEditor/importSpecifiers.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, test } from "bun:test";
+import {
+  classifyBuiltinModule,
+  extractBuiltinModuleSpecifiers,
+  importablePackageNames,
+  importSpecifierCompletionContext,
+  mergeImportCompletionEntries,
+  packageNameFromSpecifier,
+  parseBareImportSpecifiers,
+  planAcquisitions,
+} from "./importSpecifiers";
+
+describe("packageNameFromSpecifier", () => {
+  test("plain", () => {
+    expect(packageNameFromSpecifier("lodash")).toBe("lodash");
+  });
+  test("subpath", () => {
+    expect(packageNameFromSpecifier("lodash/fp")).toBe("lodash");
+  });
+  test("scoped", () => {
+    expect(packageNameFromSpecifier("@babel/core")).toBe("@babel/core");
+  });
+  test("scoped subpath", () => {
+    expect(packageNameFromSpecifier("@scope/pkg/sub/deep")).toBe("@scope/pkg");
+  });
+});
+
+describe("parseBareImportSpecifiers", () => {
+  test("default, named, namespace, side-effect, type", () => {
+    const src = [
+      `import _ from "lodash";`,
+      `import { z } from "zod";`,
+      `import * as React from "react";`,
+      `import "side-effect-pkg";`,
+      `import type { Dayjs } from "dayjs";`,
+    ].join("\n");
+    const specs = parseBareImportSpecifiers(src);
+    expect(specs.sort()).toEqual(
+      ["dayjs", "lodash", "react", "side-effect-pkg", "zod"].sort(),
+    );
+  });
+
+  test("export-from, dynamic import, require", () => {
+    const src = [
+      `export { x } from "pkg-a";`,
+      `export * from "pkg-b";`,
+      `const p = await import("pkg-c");`,
+      `const q = require("pkg-d");`,
+    ].join("\n");
+    expect(parseBareImportSpecifiers(src).sort()).toEqual(
+      ["pkg-a", "pkg-b", "pkg-c", "pkg-d"].sort(),
+    );
+  });
+
+  test("ignores relative, node:, bun, and context", () => {
+    const src = [
+      `import a from "./local";`,
+      `import b from "../up";`,
+      `import { readFile } from "node:fs";`,
+      `import { Glob } from "bun";`,
+      `const c = context.trigger;`,
+      `import "context";`,
+    ].join("\n");
+    expect(parseBareImportSpecifiers(src)).toEqual([]);
+  });
+
+  test("scoped + subpath reduce to package name, deduped", () => {
+    const src = [
+      `import { debounce } from "lodash/debounce";`,
+      `import _ from "lodash";`,
+      `import { transform } from "@babel/core/lib/x";`,
+    ].join("\n");
+    expect(parseBareImportSpecifiers(src).sort()).toEqual(
+      ["@babel/core", "lodash"].sort(),
+    );
+  });
+
+  test("the lodash named-import case (acceptance)", () => {
+    expect(parseBareImportSpecifiers(`import { debounce } from "lodash";`)).toEqual(
+      ["lodash"],
+    );
+  });
+});
+
+describe("planAcquisitions", () => {
+  test("returns only new specifiers, order-stable, deduped", () => {
+    const plan = planAcquisitions({
+      specifiers: ["lodash", "zod", "lodash", "react"],
+      acquired: new Set(["zod"]),
+    });
+    expect(plan).toEqual(["lodash", "react"]);
+  });
+  test("empty when all acquired", () => {
+    expect(
+      planAcquisitions({
+        specifiers: ["a", "b"],
+        acquired: new Set(["a", "b"]),
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe("importSpecifierCompletionContext", () => {
+  // The `partial` text starts just after the opening quote; the
+  // `replaceFromColumn` is its 1-based start column. For a line like
+  // `import {} from "lod` the partial is `lod` starting at column 17.
+  test("from-clause double quote", () => {
+    const line = `import {} from "lod`;
+    const ctx = importSpecifierCompletionContext(line);
+    expect(ctx).toEqual({ partial: "lod", replaceFromColumn: 17 });
+  });
+
+  test("from-clause single quote", () => {
+    const line = `import x from 'lo`;
+    expect(importSpecifierCompletionContext(line)).toEqual({
+      partial: "lo",
+      replaceFromColumn: 16,
+    });
+  });
+
+  test("namespace import (import * as x from)", () => {
+    const line = `import * as _ from "lod`;
+    expect(importSpecifierCompletionContext(line)?.partial).toBe("lod");
+  });
+
+  test("export ... from", () => {
+    const line = `export { x } from "lod`;
+    expect(importSpecifierCompletionContext(line)?.partial).toBe("lod");
+  });
+
+  test("bare side-effect import", () => {
+    const line = `import "lo`;
+    expect(importSpecifierCompletionContext(line)).toEqual({
+      partial: "lo",
+      replaceFromColumn: 9,
+    });
+  });
+
+  test("dynamic import()", () => {
+    const line = `const m = await import("lo`;
+    expect(importSpecifierCompletionContext(line)?.partial).toBe("lo");
+  });
+
+  test("require()", () => {
+    const line = `const m = require("lo`;
+    expect(importSpecifierCompletionContext(line)?.partial).toBe("lo");
+  });
+
+  test("scoped partial keeps the slash", () => {
+    const line = `import {} from "@scope/`;
+    expect(importSpecifierCompletionContext(line)?.partial).toBe("@scope/");
+  });
+
+  test("empty partial right after the opening quote", () => {
+    // `import {} from "` is 16 chars; the cursor sits at column 17 where the
+    // (empty) specifier begins.
+    const line = `import {} from "`;
+    expect(importSpecifierCompletionContext(line)).toEqual({
+      partial: "",
+      replaceFromColumn: 17,
+    });
+  });
+
+  test("returns null when not in an import string", () => {
+    expect(importSpecifierCompletionContext(`const x = 1;`)).toBeNull();
+    expect(importSpecifierCompletionContext(`const s = "hello`)).toBeNull();
+    expect(importSpecifierCompletionContext(`foo("bar`)).toBeNull();
+  });
+
+  test("returns null once the import string is already closed", () => {
+    expect(
+      importSpecifierCompletionContext(`import {} from "lodash"`),
+    ).toBeNull();
+    expect(importSpecifierCompletionContext(`import "lodash";`)).toBeNull();
+  });
+});
+
+describe("importablePackageNames", () => {
+  test("excludes @types/* companions", () => {
+    expect(
+      importablePackageNames(["lodash", "@types/lodash", "zod"]),
+    ).toEqual(["lodash", "zod"]);
+  });
+  test("dedupes and sorts", () => {
+    expect(
+      importablePackageNames(["zod", "lodash", "lodash", "@babel/core"]),
+    ).toEqual(["@babel/core", "lodash", "zod"]);
+  });
+  test("scoped non-@types names are kept", () => {
+    expect(importablePackageNames(["@babel/core", "@types/babel__core"])).toEqual(
+      ["@babel/core"],
+    );
+  });
+});
+
+describe("extractBuiltinModuleSpecifiers", () => {
+  // A small fixture mirroring how @types/node + bun-types declare importable
+  // modules (top-level `declare module "<spec>"`) alongside wildcard / asset
+  // shims that must be filtered out.
+  const fixture = [
+    `declare module "node:fs" { export function readFile(): void; }`,
+    `declare module "fs" { export function readFile(): void; }`,
+    `declare module 'node:path' { export const sep: string; }`,
+    `declare module "bun" { export const version: string; }`,
+    `declare module "bun:test" { export function test(): void; }`,
+    // Noise that must be dropped:
+    `declare module "*" { const c: unknown; export default c; }`,
+    `declare module "*.css" { const c: string; export default c; }`,
+    `declare module "*.txt" { const c: string; export default c; }`,
+  ].join("\n");
+
+  test("keeps real importable specifiers, drops wildcard/asset shims", () => {
+    expect(extractBuiltinModuleSpecifiers(fixture)).toEqual([
+      "bun",
+      "bun:test",
+      "fs",
+      "node:fs",
+      "node:path",
+    ]);
+  });
+
+  test("dedupes a repeated declaration", () => {
+    const src = `declare module "fs" {}\ndeclare module "fs" {}`;
+    expect(extractBuiltinModuleSpecifiers(src)).toEqual(["fs"]);
+  });
+
+  test("does not match an augmentation indented as a non-statement", () => {
+    // A `declare module` nested under another block won't be at line start;
+    // our anchor (`^\s*`) still allows leading whitespace, which is correct
+    // for real top-level declarations. This asserts the simple line-start
+    // behavior: a name on its own line is captured.
+    const src = `  declare module "node:os" {}`;
+    expect(extractBuiltinModuleSpecifiers(src)).toEqual(["node:os"]);
+  });
+
+  test("empty input yields empty list", () => {
+    expect(extractBuiltinModuleSpecifiers("")).toEqual([]);
+  });
+});
+
+describe("classifyBuiltinModule", () => {
+  test("bun and bun: specifiers are Bun built-ins", () => {
+    expect(classifyBuiltinModule("bun").detail).toBe("Bun built-in");
+    expect(classifyBuiltinModule("bun:test").detail).toBe("Bun built-in");
+  });
+  test("node and bare builtins are Node.js", () => {
+    expect(classifyBuiltinModule("node:fs").detail).toBe("Node.js");
+    expect(classifyBuiltinModule("fs").detail).toBe("Node.js");
+  });
+});
+
+describe("mergeImportCompletionEntries", () => {
+  test("built-ins always present; installed packages merged; sorted", () => {
+    const merged = mergeImportCompletionEntries({
+      builtins: ["node:fs", "bun"],
+      installedPackages: ["lodash", "zod"],
+    });
+    expect(merged.map((e) => e.name)).toEqual([
+      "bun",
+      "lodash",
+      "node:fs",
+      "zod",
+    ]);
+    expect(merged.find((e) => e.name === "bun")?.detail).toBe("Bun built-in");
+    expect(merged.find((e) => e.name === "node:fs")?.detail).toBe("Node.js");
+    expect(merged.find((e) => e.name === "lodash")?.detail).toBe(
+      "installed package",
+    );
+  });
+
+  test("built-ins present even with an empty allowlist", () => {
+    const merged = mergeImportCompletionEntries({
+      builtins: ["node:fs", "bun"],
+      installedPackages: [],
+    });
+    expect(merged.map((e) => e.name)).toEqual(["bun", "node:fs"]);
+  });
+
+  test("an installed package colliding with a built-in is labelled installed", () => {
+    const merged = mergeImportCompletionEntries({
+      builtins: ["fs"],
+      installedPackages: ["fs"],
+    });
+    expect(merged).toEqual([{ name: "fs", detail: "installed package" }]);
+  });
+});