@stigmer/cli 3.35.0 → 3.36.0

package/src/marketplace/official.test.ts

@@ -1,107 +0,0 @@
-// Pins the official marketplace's resolution: the repo tree wins when this
-// module runs from a checkout; otherwise the package is acquired once at the
-// CLI's version into the runtimes root, reused on the next call, and refused
-// for a non-release build that has nothing installed.
-
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  acquireOfficialMarketplace,
-  resolveOfficialMarketplace,
-} from "./official.js";
-
-let home: string;
-
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "stigmer-official-marketplace-"));
-});
-
-afterEach(() => {
-  rmSync(home, { recursive: true, force: true });
-});
-
-function fakeInstall(installDir: string): void {
-  const pkg = join(installDir, "node_modules", "@stigmer", "plugins");
-  mkdirSync(pkg, { recursive: true });
-  writeFileSync(
-    join(pkg, "marketplace.json"),
-    JSON.stringify({ name: "stigmer", plugins: [] }),
-  );
-}
-
-describe("resolveOfficialMarketplace", () => {
-  it("uses the repo tree when running from a checkout", () => {
-    const resolved = resolveOfficialMarketplace({ home });
-    expect(resolved.source).toBe("repo");
-    expect(resolved.dir.endsWith(join("", "plugins"))).toBe(true);
-  });
-
-  it("acquires the package when there is no checkout, once, and reuses it", () => {
-    let installs = 0;
-    const install = (installDir: string): void => {
-      installs += 1;
-      fakeInstall(installDir);
-    };
-    const first = resolveOfficialMarketplace({
-      home,
-      version: "1.2.3",
-      install,
-      repoDir: () => null,
-    });
-    const second = resolveOfficialMarketplace({
-      home,
-      version: "1.2.3",
-      install,
-      repoDir: () => null,
-    });
-    expect(first.source).toBe("package");
-    expect(first.dir).toBe(
-      join(
-        home,
-        ".stigmer",
-        "runtimes",
-        "1.2.3",
-        "node_modules",
-        "@stigmer",
-        "plugins",
-      ),
-    );
-    expect(second.dir).toBe(first.dir);
-    expect(installs).toBe(1);
-  });
-});
-
-describe("acquireOfficialMarketplace", () => {
-  it("refuses to acquire for a non-release build with nothing installed", () => {
-    expect(() =>
-      acquireOfficialMarketplace({
-        home,
-        version: "0.0.0-dev",
-        install: () => {},
-      }),
-    ).toThrow(/cannot acquire @stigmer\/plugins for a non-release build/);
-  });
-
-  it("uses already-installed content even for a non-release build", () => {
-    const installDir = join(home, ".stigmer", "runtimes", "0.0.0-dev");
-    fakeInstall(installDir);
-    let installs = 0;
-    const dir = acquireOfficialMarketplace({
-      home,
-      version: "0.0.0-dev",
-      install: () => {
-        installs += 1;
-      },
-    });
-    expect(dir).toBe(join(installDir, "node_modules", "@stigmer", "plugins"));
-    expect(installs).toBe(0);
-  });
-
-  it("refuses when the install did not produce the marketplace file", () => {
-    expect(() =>
-      acquireOfficialMarketplace({ home, version: "1.2.3", install: () => {} }),
-    ).toThrow(/install did not produce/);
-  });
-});

package/src/marketplace/read.test.ts

@@ -1,93 +0,0 @@
-// Pins the CLI's edge for the marketplace reader: a tree read through the one
-// walker, the refusal shape, entry lookup and directory resolution, and the
-// official tree in this repository reading clean.
-
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { writeCursorMarketplace } from "./__fixtures__/cursor-marketplace.js";
-import { resolveOfficialMarketplace } from "./official.js";
-import { entryDirectory, findEntry, readMarketplaceTree } from "./read.js";
-
-let root: string;
-
-beforeAll(() => {
-  root = mkdtempSync(join(tmpdir(), "stigmer-marketplace-read-"));
-  writeCursorMarketplace(root);
-});
-
-afterAll(() => {
-  rmSync(root, { recursive: true, force: true });
-});
-
-describe("readMarketplaceTree", () => {
-  it("reads a Cursor-dialect tree into the one shape, dropping the missing entry with its sentence", () => {
-    const tree = readMarketplaceTree(root);
-    expect(tree.marketplace.name).toBe("acme-plugins");
-    expect(tree.marketplace.dialect).toBe("cursor");
-    expect(tree.marketplace.plugins.map((entry) => entry.name)).toEqual([
-      "warmer",
-      "codeforge",
-    ]);
-    expect(tree.warnings).toHaveLength(1);
-    expect(tree.warnings[0]?.kind).toBe("entry-directory-missing");
-    expect(tree.warnings[0]?.subject).toBe("ghost");
-  });
-
-  it("refuses a directory with no marketplace file, naming the four locations", () => {
-    const empty = mkdtempSync(join(tmpdir(), "stigmer-marketplace-empty-"));
-    try {
-      writeFileSync(join(empty, "README.md"), "nothing here");
-      expect(() => readMarketplaceTree(empty, "github.com/a/b")).toThrow(
-        /github\.com\/a\/b: not a marketplace this CLI can read, 1 problem found:\n  - .*marketplace\.json/,
-      );
-    } finally {
-      rmSync(empty, { recursive: true, force: true });
-    }
-  });
-
-  it("refuses a broken file with every problem and every warning", () => {
-    const broken = mkdtempSync(join(tmpdir(), "stigmer-marketplace-broken-"));
-    try {
-      writeFileSync(
-        join(broken, "marketplace.json"),
-        JSON.stringify({
-          plugins: [
-            { name: "a", source: "../out" },
-            { name: "b", source: "https://x" },
-          ],
-        }),
-      );
-      expect(() => readMarketplaceTree(broken)).toThrow(
-        /2 problems found:[\s\S]*and 1 warning:/,
-      );
-    } finally {
-      rmSync(broken, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("findEntry and entryDirectory", () => {
-  it("resolves an offered entry to its absolute directory and an unknown name to undefined", () => {
-    const tree = readMarketplaceTree(root);
-    const codeforge = findEntry(tree.marketplace, "codeforge");
-    expect(codeforge?.dir).toBe("third_party/codeforge");
-    expect(entryDirectory(tree, codeforge!)).toBe(
-      join(root, "third_party", "codeforge"),
-    );
-    expect(findEntry(tree.marketplace, "ghost")).toBeUndefined();
-  });
-});
-
-describe("the official tree in this repository", () => {
-  it("reads clean through the CLI walker", () => {
-    const official = resolveOfficialMarketplace();
-    expect(official.source).toBe("repo");
-    const tree = readMarketplaceTree(official.dir);
-    expect(tree.marketplace.name).toBe("stigmer");
-    expect(tree.marketplace.dialect).toBe("stigmer");
-    expect(tree.warnings).toEqual([]);
-    expect(findEntry(tree.marketplace, "linear")?.dir).toBe("linear");
-  });
-});

package/src/marketplace/ref.test.ts

@@ -1,179 +0,0 @@
-// Pins the two grammars: every accepted form of `[marketplace/]name[@version]`
-// and every refusal with its sentence; every accepted form of an `add`
-// source (a directory wins, then owner/repo[@ref], then the GitHub URL) and
-// the refusals.
-
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { formatInstallRef, parseAddSource, parseInstallRef } from "./ref.js";
-
-describe("parseInstallRef", () => {
-  it("reads a bare name, a marketplace prefix, a version, and all three", () => {
-    expect(parseInstallRef("thermos")).toEqual({ name: "thermos" });
-    expect(parseInstallRef("cursor-plugins/thermos")).toEqual({
-      marketplace: "cursor-plugins",
-      name: "thermos",
-    });
-    expect(parseInstallRef("thermos@1.0.0")).toEqual({
-      name: "thermos",
-      version: "1.0.0",
-    });
-    expect(parseInstallRef("stigmer/assistant@1.0.0")).toEqual({
-      marketplace: "stigmer",
-      name: "assistant",
-      version: "1.0.0",
-    });
-    expect(parseInstallRef("third.party-x@v2-rc.1")).toEqual({
-      name: "third.party-x",
-      version: "v2-rc.1",
-    });
-  });
-
-  it("round-trips through formatInstallRef", () => {
-    for (const text of [
-      "thermos",
-      "cursor-plugins/thermos",
-      "thermos@1.0.0",
-      "a/b@c",
-    ]) {
-      expect(formatInstallRef(parseInstallRef(text))).toBe(text);
-    }
-  });
-
-  it("refuses a path toward push plugin", () => {
-    for (const path of [
-      "./thermos",
-      "../x",
-      "/tmp/plugin",
-      ".",
-      "..",
-      "~/plugins",
-      "C:\\plugins",
-    ]) {
-      expect(() => parseInstallRef(path)).toThrow(
-        /is a path.*stigmer push plugin/s,
-      );
-    }
-  });
-
-  it("refuses names and versions outside the grammar, naming the part", () => {
-    expect(() => parseInstallRef("Thermos")).toThrow(
-      /'Thermos' is not a plugin name/,
-    );
-    expect(() => parseInstallRef("a/b/c")).toThrow(
-      /'b\/c' is not a plugin name/,
-    );
-    expect(() => parseInstallRef("Bad/thermos")).toThrow(
-      /'Bad' is not a marketplace name/,
-    );
-    expect(() => parseInstallRef("thermos@")).toThrow(/'' is not a version/);
-    expect(() => parseInstallRef("thermos@1.0+build")).toThrow(
-      /'1.0\+build' is not a version/,
-    );
-    expect(() => parseInstallRef("")).toThrow(/'' is not a plugin name/);
-    expect(() => parseInstallRef("a@b@c")).toThrow(/'b@c' is not a version/);
-  });
-});
-
-describe("parseAddSource", () => {
-  let cwd: string;
-
-  beforeAll(() => {
-    cwd = mkdtempSync(join(tmpdir(), "stigmer-add-source-"));
-    mkdirSync(join(cwd, "plugins"));
-    mkdirSync(join(cwd, "cursor", "plugins"), { recursive: true });
-  });
-
-  afterAll(() => {
-    rmSync(cwd, { recursive: true, force: true });
-  });
-
-  it("reads an existing directory as local, stored absolute, before any other reading", () => {
-    expect(parseAddSource("plugins", cwd)).toEqual({
-      type: "local",
-      path: join(cwd, "plugins"),
-    });
-    expect(parseAddSource("./plugins/", cwd)).toEqual({
-      type: "local",
-      path: join(cwd, "plugins"),
-    });
-    expect(parseAddSource(join(cwd, "plugins"), cwd)).toEqual({
-      type: "local",
-      path: join(cwd, "plugins"),
-    });
-    // A directory named like an owner/repo is the directory.
-    expect(parseAddSource("cursor/plugins", cwd)).toEqual({
-      type: "local",
-      path: join(cwd, "cursor", "plugins"),
-    });
-  });
-
-  it("reads owner/repo and owner/repo@ref as github when no such directory exists", () => {
-    expect(parseAddSource("anthropics/claude-code", cwd)).toEqual({
-      type: "github",
-      repo: "anthropics/claude-code",
-    });
-    expect(parseAddSource("anthropics/claude-code@v1.0", cwd)).toEqual({
-      type: "github",
-      repo: "anthropics/claude-code",
-      ref: "v1.0",
-    });
-    expect(parseAddSource("openai/codex@refs/heads/main", cwd)).toEqual({
-      type: "github",
-      repo: "openai/codex",
-      ref: "refs/heads/main",
-    });
-  });
-
-  it("unwraps the GitHub URL a browser shows, with or without a tree ref", () => {
-    expect(parseAddSource("https://github.com/cursor/plugins", cwd)).toEqual({
-      type: "github",
-      repo: "cursor/plugins",
-    });
-    expect(parseAddSource("https://github.com/cursor/plugins/", cwd)).toEqual({
-      type: "github",
-      repo: "cursor/plugins",
-    });
-    expect(
-      parseAddSource("https://github.com/cursor/plugins.git", cwd),
-    ).toEqual({ type: "github", repo: "cursor/plugins" });
-    expect(
-      parseAddSource("https://www.github.com/cursor/plugins/tree/main", cwd),
-    ).toEqual({
-      type: "github",
-      repo: "cursor/plugins",
-      ref: "main",
-    });
-    expect(
-      parseAddSource("http://github.com/openai/codex/tree/release/1.2", cwd),
-    ).toEqual({
-      type: "github",
-      repo: "openai/codex",
-      ref: "release/1.2",
-    });
-  });
-
-  it("refuses what is neither, naming the three forms", () => {
-    expect(() => parseAddSource("", cwd)).toThrow(/source is required/);
-    expect(() => parseAddSource("missing-dir", cwd)).toThrow(
-      /not a marketplace source/,
-    );
-    expect(() => parseAddSource("./missing-dir", cwd)).toThrow(
-      /not a directory on this machine and not a GitHub/,
-    );
-    expect(() => parseAddSource("a/b/c", cwd)).toThrow(
-      /not a directory on this machine and not a GitHub/,
-    );
-    expect(() => parseAddSource("cursor/plugins@", cwd)).toThrow(
-      /not a marketplace source|not a directory/,
-    );
-    expect(() => parseAddSource("https://gitlab.com/a/b", cwd)).toThrow(
-      /not a directory on this machine and not a GitHub/,
-    );
-    expect(() => parseAddSource("https://github.com/cursor", cwd)).toThrow(
-      /not a directory on this machine and not a GitHub/,
-    );
-  });
-});

package/src/output/command-result.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CommandResult, resultToHuman, resultToJson, resultToQuiet } from "./command-result.js";
-
-describe("resultToJson", () => {
-  it("emits status as a lowercase string", () => {
-    expect(JSON.parse(resultToJson(CommandResult.success("ok"))).status).toBe("success");
-    expect(JSON.parse(resultToJson(CommandResult.warning("w"))).status).toBe("warning");
-    expect(JSON.parse(resultToJson(CommandResult.error("e"))).status).toBe("error");
-  });
-
-  it("omits empty sections and hints", () => {
-    const parsed = JSON.parse(resultToJson(CommandResult.success("done")));
-    expect(parsed).not.toHaveProperty("sections");
-    expect(parsed).not.toHaveProperty("hints");
-  });
-
-  it("serializes sections (fields + items) and hints", () => {
-    const result = CommandResult.success("Created");
-    result.addSection("Details").field("ID", "abc").field("Name", "agent");
-    result.addSection("Items").item("first").item("second");
-    result.hint("try this").hint("and that");
-
-    const parsed = JSON.parse(resultToJson(result));
-    expect(parsed.sections).toHaveLength(2);
-    expect(parsed.sections[0]).toEqual({
-      title: "Details",
-      fields: [
-        { key: "ID", value: "abc" },
-        { key: "Name", value: "agent" },
-      ],
-    });
-    expect(parsed.sections[1]).toEqual({ title: "Items", items: ["first", "second"] });
-    expect(parsed.hints).toEqual(["try this", "and that"]);
-  });
-
-  it("emits the data payload in JSON only, and omits it when unset", () => {
-    const result = CommandResult.warning("Plugin is valid").withData({ plugin: { name: "x" }, warnings: [] });
-    const parsed = JSON.parse(resultToJson(result));
-    expect(parsed.data).toEqual({ plugin: { name: "x" }, warnings: [] });
-    expect(JSON.parse(resultToJson(CommandResult.success("ok")))).not.toHaveProperty("data");
-    expect(resultToHuman(result, false)).not.toContain("plugin");
-    expect(resultToQuiet(result, false)).toBe("⚠ Plugin is valid\n");
-  });
-});
-
-describe("resultToHuman (plain, no color)", () => {
-  it("renders the status icon, message, fields, and hints", () => {
-    const result = CommandResult.success("Created agent");
-    result.addSection("Details").field("ID", "agt-123");
-    result.hint("Run: stigmer get agent agt-123");
-
-    const out = resultToHuman(result, false);
-    expect(out).toContain("✓ Created agent");
-    expect(out).toContain("Details:");
-    expect(out).toContain("ID");
-    expect(out).toContain("agt-123");
-    expect(out).toContain("Run: stigmer get agent agt-123");
-  });
-
-  it("uses an error icon for error results", () => {
-    expect(resultToHuman(CommandResult.error("boom"), false)).toContain("✗ boom");
-  });
-});
-
-describe("resultToQuiet (plain, no color)", () => {
-  it("renders only the status line", () => {
-    const result = CommandResult.success("Done");
-    result.addSection("Details").field("ID", "abc");
-    const out = resultToQuiet(result, false);
-    expect(out).toBe("✓ Done\n");
-    expect(out).not.toContain("Details");
-  });
-});

package/src/output/confirm.test.ts

@@ -1,43 +0,0 @@
-import { PassThrough } from "node:stream";
-import { describe, expect, it } from "vitest";
-import { confirm } from "./confirm.js";
-
-// A PassThrough masquerading as an interactive TTY input, with a writable sink
-// for the prompt text we don't need to inspect.
-function ttyPair(isTTY: boolean): { input: NodeJS.ReadStream; output: NodeJS.WritableStream } {
-  const input = new PassThrough();
-  (input as unknown as { isTTY: boolean }).isTTY = isTTY;
-  return { input: input as unknown as NodeJS.ReadStream, output: new PassThrough() };
-}
-
-async function answer(reply: string): Promise<boolean> {
-  const { input, output } = ttyPair(true);
-  const pending = confirm("Proceed? [y/N]", { input, output });
-  (input as unknown as PassThrough).write(`${reply}\n`);
-  return pending;
-}
-
-describe("confirm", () => {
-  it("auto-confirms when forced, without reading input", async () => {
-    expect(await confirm("Proceed? [y/N]", { force: true })).toBe(true);
-  });
-
-  it("refuses (no prompt) when input is not a TTY", async () => {
-    const { input, output } = ttyPair(false);
-    expect(await confirm("Proceed? [y/N]", { input, output })).toBe(false);
-  });
-
-  it.each([
-    ["y", true],
-    ["Y", true],
-    ["yes", true],
-    ["YES", true],
-    [" y ", true],
-    ["n", false],
-    ["no", false],
-    ["", false],
-    ["nope", false],
-  ])("interprets %j as %s", async (reply, expected) => {
-    expect(await answer(reply)).toBe(expected);
-  });
-});

package/src/output/format.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { UsageError } from "../errors/usage-error.js";
-import { resolveFormat, supportedFormats } from "./format.js";
-
-describe("resolveFormat — defaults per command class", () => {
-  it("defaults reads to table", () => {
-    expect(resolveFormat({}, "read")).toBe("table");
-  });
-  it("defaults mutations to human", () => {
-    expect(resolveFormat({}, "mutating")).toBe("human");
-  });
-  it("defaults streaming to inline", () => {
-    expect(resolveFormat({}, "streaming")).toBe("inline");
-  });
-});
-
-describe("resolveFormat — --json alias resolves per class", () => {
-  it("maps --json to json for reads", () => {
-    expect(resolveFormat({ json: true }, "read")).toBe("json");
-  });
-  it("maps --json to json for mutations", () => {
-    expect(resolveFormat({ json: true }, "mutating")).toBe("json");
-  });
-  it("maps --json to ndjson for streaming", () => {
-    expect(resolveFormat({ json: true }, "streaming")).toBe("ndjson");
-  });
-});
-
-describe("resolveFormat — --quiet alias", () => {
-  it("maps --quiet to quiet for mutations", () => {
-    expect(resolveFormat({ quiet: true }, "mutating")).toBe("quiet");
-  });
-  it("rejects --json together with --quiet", () => {
-    expect(() => resolveFormat({ json: true, quiet: true }, "mutating")).toThrow(UsageError);
-  });
-});
-
-describe("resolveFormat — explicit -o/--output", () => {
-  it("maps universal table -> human for mutations", () => {
-    expect(resolveFormat({ output: "table" }, "mutating")).toBe("human");
-  });
-  it("maps universal table -> inline for streaming", () => {
-    expect(resolveFormat({ output: "table" }, "streaming")).toBe("inline");
-  });
-  it("accepts yaml for reads", () => {
-    expect(resolveFormat({ output: "yaml" }, "read")).toBe("yaml");
-  });
-  it("is case-insensitive", () => {
-    expect(resolveFormat({ output: "JSON" }, "read")).toBe("json");
-  });
-  it("rejects an unknown universal value", () => {
-    expect(() => resolveFormat({ output: "xml" }, "read")).toThrow(/invalid --output value/);
-  });
-  it("rejects yaml for mutations (unsupported by the class)", () => {
-    expect(() => resolveFormat({ output: "yaml" }, "mutating")).toThrow(/not supported/);
-  });
-});
-
-describe("supportedFormats", () => {
-  it("lists the universal values each class supports", () => {
-    expect(supportedFormats("read")).toEqual(["table", "json", "yaml"]);
-    expect(supportedFormats("mutating")).toEqual(["table", "json"]);
-    expect(supportedFormats("streaming")).toEqual(["table", "json", "ndjson"]);
-  });
-});

package/src/output/proto.test.ts

@@ -1,72 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { ApiResourceKindMetaSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
-import { parse as parseYaml } from "yaml";
-import { describe, expect, it } from "vitest";
-import {
-  protoToJsonValue,
-  renderProtoJson,
-  renderProtoListJson,
-  renderProtoListYaml,
-  renderProtoYaml,
-} from "./proto.js";
-
-// A small, stable generated message exercising snake_case fields (display_name,
-// id_prefix, is_versioned) and default-omission (group/version/tier enums = 0).
-function sampleMeta() {
-  return create(ApiResourceKindMetaSchema, {
-    name: "Agent",
-    displayName: "Agent",
-    idPrefix: "agt",
-    isVersioned: true,
-  });
-}
-
-describe("renderProtoJson — protojson parity", () => {
-  it("uses proto (snake_case) field names", () => {
-    const parsed = JSON.parse(renderProtoJson(ApiResourceKindMetaSchema, sampleMeta()));
-    expect(parsed).toEqual({
-      name: "Agent",
-      display_name: "Agent",
-      id_prefix: "agt",
-      is_versioned: true,
-    });
-  });
-
-  it("omits unpopulated (default-valued) fields", () => {
-    const parsed = JSON.parse(renderProtoJson(ApiResourceKindMetaSchema, sampleMeta()));
-    expect(parsed).not.toHaveProperty("group");
-    expect(parsed).not.toHaveProperty("tier");
-    expect(parsed).not.toHaveProperty("authorization");
-  });
-
-  it("pretty-prints with a trailing newline", () => {
-    const rendered = renderProtoJson(ApiResourceKindMetaSchema, sampleMeta());
-    expect(rendered.endsWith("\n")).toBe(true);
-    expect(rendered).toContain('  "name": "Agent"');
-  });
-});
-
-describe("renderProtoYaml — round-trips through the same JSON value", () => {
-  it("yields the same field names and values as the JSON renderer", () => {
-    const meta = sampleMeta();
-    const fromYaml = parseYaml(renderProtoYaml(ApiResourceKindMetaSchema, meta));
-    expect(fromYaml).toEqual(protoToJsonValue(ApiResourceKindMetaSchema, meta));
-  });
-});
-
-describe("list renderers", () => {
-  it("renders a JSON array of messages", () => {
-    const parsed = JSON.parse(
-      renderProtoListJson(ApiResourceKindMetaSchema, [sampleMeta(), sampleMeta()]),
-    );
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed).toHaveLength(2);
-    expect(parsed[0].id_prefix).toBe("agt");
-  });
-
-  it("renders a YAML array equal to the JSON-value array", () => {
-    const items = [sampleMeta()];
-    const fromYaml = parseYaml(renderProtoListYaml(ApiResourceKindMetaSchema, items));
-    expect(fromYaml).toEqual(items.map((m) => protoToJsonValue(ApiResourceKindMetaSchema, m)));
-  });
-});

package/src/output/table.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { renderEmpty, renderTable } from "./table.js";
-
-describe("renderTable", () => {
-  it("returns empty string for no rows", () => {
-    expect(renderTable(["NAME", "KIND"], [])).toBe("");
-  });
-
-  it("renders aligned columns with a dash separator", () => {
-    const out = renderTable(
-      ["NAME", "KIND"],
-      [
-        ["my-agent", "agent"],
-        ["wf", "workflow"],
-      ],
-    );
-    const lines = out.trimEnd().split("\n");
-    expect(lines[0]).toBe("NAME       KIND");
-    expect(lines[1]).toBe("--------   --------");
-    expect(lines[2]).toBe("my-agent   agent");
-    expect(lines[3]).toBe("wf         workflow");
-  });
-
-  it("tolerates short rows by padding missing cells", () => {
-    const out = renderTable(["A", "B"], [["only"]]);
-    expect(out.trimEnd().split("\n")[2]).toBe("only");
-  });
-});
-
-describe("renderEmpty", () => {
-  it("reports an unfiltered empty state", () => {
-    expect(renderEmpty("agents")).toBe("\nNo agents found\n\n");
-  });
-  it("reports a query-filtered empty state", () => {
-    expect(renderEmpty("agents", "foo")).toBe("\nNo agents found matching 'foo'\n\n");
-  });
-});