@intentius/chant 0.79.0 → 0.81.0

package/src/cli/main.test.ts

@@ -1,6 +1,8 @@
 import { describe, test, expect } from "vitest";
 import { EventEmitter } from "node:events";
-import { parseArgs, waitForStreamDrain } from "./main";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { commandRegistry, parseArgs, waitForStreamDrain } from "./main";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
 
 describe("parseArgs", () => {
@@ -267,6 +269,18 @@ describe("parseArgs", () => {
     expect(result.actor).toBe("alice");
   });
 
+  test("--digest repeats for components promote, and --digest-file is parsed (#2602)", () => {
+    const promote = parseArgs([
+      "components", "promote", "--from", "staging", "--to", "prod",
+      "--digest", "api=sha256:a", "--digest", "web=sha256:w",
+    ]);
+    expect(promote.digests).toEqual(["api=sha256:a", "web=sha256:w"]);
+    expect(promote.digest).toBe("web=sha256:w");
+
+    const run = parseArgs(["run", "--components", "api", "--env", "staging", "--digest-file", "api.digest"]);
+    expect(run.digestFile).toBe("api.digest");
+  });
+
   test("parses --compare-to and --live for components status", () => {
     const result = parseArgs(["components", "status", "prod", "--compare-to", "staging", "--live", "--json"]);
     expect(result.command).toBe("components");
@@ -298,6 +312,23 @@ describe("parseArgs", () => {
 
   // ── --no-release-record (#597) ───────────────────────────────────────────
 
+  test("--promote-to <env> sets promoteTo, and a missing value is refused (#2575)", () => {
+    expect(parseArgs(["build", "--components", "--generate", "github", "--promote-to", "prod"]).promoteTo).toBe("prod");
+    expect(() => parseArgs(["build", "--components", "--generate", "github", "--promote-to"])).toThrow(/--promote-to needs an environment/);
+    expect(() => parseArgs(["build", "--promote-to", "--env", "x"])).toThrow(/--promote-to needs an environment/);
+  });
+
+  test("--promote-to outside build --components --generate is refused, naming the flags it needs (#2603)", () => {
+    const needs = /--promote-to needs build --components --generate <lexicon>/;
+    expect(() => parseArgs(["build", "--promote-to", "prod"])).toThrow(needs);
+    expect(() => parseArgs(["build", "--components", "--promote-to", "prod"])).toThrow(needs);
+    expect(() => parseArgs(["build", "--generate", "github", "--promote-to", "prod"])).toThrow(needs);
+    expect(() => parseArgs(["run", "--components", "all", "--generate", "github", "--promote-to", "prod"])).toThrow(needs);
+    expect(() => parseArgs(["components", "promote", "--from", "staging", "--promote-to", "prod"])).toThrow(needs);
+    // Flag order does not matter: the check runs once the whole line is parsed.
+    expect(parseArgs(["build", "--promote-to", "prod", "--generate", "gitlab", "--components"]).promoteTo).toBe("prod");
+  });
+
   test("parses --no-release-record for run --components", () => {
     const result = parseArgs(["run", "--components", "search-service", "--env", "staging", "--no-release-record"]);
     expect(result.components).toBe(true);
@@ -633,6 +664,78 @@ describe("parseArgs — run flags", () => {
   });
 });
 
+describe("workspace records (#2546)", () => {
+  test("parses --kind, --current, --at and --json", () => {
+    const args = parseArgs(["workspace", "records", "--kind", "docs/k.kind.mjs", "--current", "--at", "HEAD~1", "--json"]);
+    expect(args).toMatchObject({ command: "workspace", path: "records", kind: "docs/k.kind.mjs", current: true, at: "HEAD~1", json: true });
+    expect(parseArgs(["workspace", "records", "--kind=docs/k.kind.mjs"]).kind).toBe("docs/k.kind.mjs");
+    expect(parseArgs(["workspace", "records"]).current).toBeUndefined();
+    expect(() => parseArgs(["workspace", "records", "--kind"])).toThrow(/--kind needs a kind file/);
+    expect(() => parseArgs(["workspace", "records", "--kind", "--json"])).toThrow(/--kind needs a kind file/);
+  });
+
+  test("resolves to the records command, and anything else under workspace to its fallback", () => {
+    expect(resolveCommand(parseArgs(["workspace", "records", "--kind", "k.mjs"]), commandRegistry)?.def.name).toBe("workspace records");
+    expect(resolveCommand(parseArgs(["workspace", "no-such-subcommand"]), commandRegistry)?.def.name).toBe("workspace");
+  });
+
+  // #2525 rule 5: the workspace code loads only when a workspace command runs.
+  // The level-0 goldens catch it at run time; this catches it in review.
+  test("main.ts never imports workspace code statically", () => {
+    const source = readFileSync(join(import.meta.dirname, "main.ts"), "utf-8");
+    expect(source).not.toMatch(/^import[^;]*from\s+["'][^"']*workspace/m);
+    expect(source).toMatch(/await import\("\.\.\/workspace\/records-cli"\)/);
+  });
+});
+
+describe("workspace init and ls (#2534)", () => {
+  test("resolve to their commands in the one workspace group, with the directory as extra positional", () => {
+    const ls = parseArgs(["workspace", "ls", "examples", "--at", "HEAD", "--json"]);
+    expect(ls).toMatchObject({ command: "workspace", path: "ls", extraPositional: "examples", at: "HEAD", json: true });
+    expect(resolveCommand(ls, commandRegistry)?.def.name).toBe("workspace ls");
+    const init = parseArgs(["workspace", "init", "--name", "acme", "--yes"]);
+    expect(init).toMatchObject({ command: "workspace", path: "init", selectName: "acme", yes: true });
+    expect(resolveCommand(init, commandRegistry)?.def.name).toBe("workspace init");
+    expect(commandRegistry.filter((c) => c.name === "workspace" || c.name.startsWith("workspace ")).map((c) => c.name).sort()).toEqual([
+      "workspace",
+      "workspace audit",
+      "workspace build",
+      "workspace check",
+      "workspace graph",
+      "workspace init",
+      "workspace lineage",
+      "workspace lint",
+      "workspace ls",
+      "workspace member-run",
+      "workspace records",
+      "workspace status",
+      "workspace upgrade",
+      "workspace verify",
+    ]);
+  });
+
+  test("load their modules only when they run", () => {
+    const source = readFileSync(join(import.meta.dirname, "main.ts"), "utf-8");
+    expect(source).toMatch(/await import\("\.\.\/workspace\/init"\)/);
+    expect(source).toMatch(/await import\("\.\.\/workspace\/ls"\)/);
+  });
+});
+
+describe("workspace status (#2544)", () => {
+  test("takes the environment as extra positional, a directory after it, and --compare-to", () => {
+    const status = parseArgs(["workspace", "status", "staging", "apps", "--compare-to", "prod", "--json"]);
+    expect(status).toMatchObject({ command: "workspace", path: "status", extraPositional: "staging", extraPositional2: "apps", compareTo: "prod", json: true });
+    expect(resolveCommand(status, commandRegistry)?.def.name).toBe("workspace status");
+    // --compare-to --live parses, so the command can say live isn't read yet.
+    expect(parseArgs(["workspace", "status", "prod", "--compare-to", "--live"]).compareTo).toBe("--live");
+  });
+
+  test("loads its module only when it runs", () => {
+    const source = readFileSync(join(import.meta.dirname, "main.ts"), "utf-8");
+    expect(source).toMatch(/await import\("\.\.\/workspace\/status"\)/);
+  });
+});
+
 describe("waitForStreamDrain", () => {
   // Minimal writable stub — just the surface waitForStreamDrain reads.
   function fakeStream(len: number): NodeJS.WriteStream & { writableLength: number } {
@@ -679,3 +782,36 @@ describe("waitForStreamDrain", () => {
     await expect(p).resolves.toBeUndefined();
   });
 });
+
+describe("per-member commands and the root refusal (#2537)", () => {
+  test("--root-only is a boolean, and --member repeats and splits on commas", () => {
+    expect(parseArgs(["build", "--root-only"]).rootOnly).toBe(true);
+    expect(parseArgs(["lint", "src"]).rootOnly).toBeUndefined();
+    expect(() => parseArgs(["build", "--root-only=yes"])).toThrow();
+    const args = parseArgs(["workspace", "lint", "--member", "api,web", "--member", "examples", "--format", "sarif"]);
+    expect(args).toMatchObject({ command: "workspace", path: "lint", members: ["api", "web", "examples"], format: "sarif" });
+    expect(() => parseArgs(["workspace", "build", "--member"])).toThrow(/--member needs a member or group name/);
+  });
+
+  test("workspace build, lint, audit and graph resolve to their commands", () => {
+    for (const verb of ["build", "lint", "audit", "graph"]) {
+      expect(resolveCommand(parseArgs(["workspace", verb, "some/dir"]), commandRegistry)?.def.name).toBe(`workspace ${verb}`);
+    }
+  });
+
+  test("the refusal and the per-member code load only when used", () => {
+    const source = readFileSync(join(import.meta.dirname, "main.ts"), "utf-8");
+    expect(source).toMatch(/await import\("\.\.\/workspace\/root-refusal"\)/);
+    expect(source).toMatch(/await import\("\.\.\/workspace\/member-commands"\)/);
+    expect(source).toMatch(/await import\("\.\.\/workspace\/member-run"\)/);
+  });
+});
+
+describe("chant workspace check --generated (#2641)", () => {
+  test("is a boolean flag, distinct from --generate <lexicon>", () => {
+    expect(parseArgs(["workspace", "check", "--generated", "--json"])).toMatchObject({ command: "workspace", path: "check", generated: true, json: true });
+    expect(parseArgs(["workspace", "check"]).generated).toBeUndefined();
+    expect(parseArgs(["build", "--generate", "github"]).generated).toBeUndefined();
+    expect(() => parseArgs(["workspace", "check", "--generated=yes"])).toThrow();
+  });
+});