@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/execution.test.ts

@@ -1,138 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { AgentExecutionListSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
-import { ExecutionPhase as WorkflowExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
-import { describe, expect, it } from "vitest";
-import { UsageError } from "../errors/index.js";
-import {
-  formatAgentPhase,
-  formatWorkflowPhase,
-  isAgentExecutionId,
-  isExecutionAlias,
-  isTerminalAgentPhase,
-  isWorkflowExecutionId,
-  renderExecutionList,
-  resolveExecutionType,
-} from "./execution.js";
-
-describe("isAgentExecutionId", () => {
-  it.each([
-    ["aex_01ARZ3NDEKTSV4RRFFQ69G5FAV", true],
-    ["aex-01ARZ3NDEKTSV4RRFFQ69G5FAV", true],
-    ["aex_", true],
-    ["AEX_run", false], // case-sensitive
-    ["agt_abc", false], // different kind
-    ["wex_run", false], // workflow, not agent
-  ])("%j -> %s", (ref, expected) => {
-    expect(isAgentExecutionId(ref)).toBe(expected);
-  });
-});
-
-describe("isWorkflowExecutionId", () => {
-  it.each([
-    ["wex_run456", true],
-    ["wex-run456", true],
-    ["WEX_run", false],
-    ["wfl_abc", false],
-    ["aex_run", false],
-  ])("%j -> %s", (ref, expected) => {
-    expect(isWorkflowExecutionId(ref)).toBe(expected);
-  });
-});
-
-describe("isExecutionAlias", () => {
-  it.each([
-    ["execution", true],
-    ["executions", true],
-    ["exec", true],
-    ["  Exec  ", true],
-    ["agent", false],
-    ["session", false],
-  ])("%j -> %s", (type, expected) => {
-    expect(isExecutionAlias(type)).toBe(expected);
-  });
-});
-
-describe("resolveExecutionType", () => {
-  it("resolves agent and workflow prefixes", () => {
-    expect(resolveExecutionType("aex_01ARZ3NDEKTSV4RRFFQ69G5FAV")).toBe("agent");
-    expect(resolveExecutionType("wex_01ARZ3NDEKTSV4RRFFQ69G5FAV")).toBe("workflow");
-  });
-
-  it("throws a usage error on an unrecognized prefix", () => {
-    expect(() => resolveExecutionType("xyz_123")).toThrow(UsageError);
-  });
-});
-
-describe("renderExecutionList", () => {
-  const list = create(AgentExecutionListSchema, {
-    totalPages: 1,
-    entries: [
-      create(AgentExecutionSchema, {
-        metadata: { id: "aex_1" },
-        spec: { agentId: "agt_1" },
-        status: { phase: ExecutionPhase.EXECUTION_IN_PROGRESS, startedAt: "2026-03-01T10:00:00Z" },
-      }),
-    ],
-  });
-  const result = { schema: AgentExecutionListSchema, message: list };
-
-  it("renders the full list envelope as protojson for json", () => {
-    const json = JSON.parse(renderExecutionList(result, "json", "agent"));
-    expect(json.total_pages).toBe(1);
-    expect(json.entries[0].metadata.id).toBe("aex_1");
-  });
-
-  it("renders a table with a friendly phase label", () => {
-    const table = renderExecutionList(result, "table", "agent");
-    expect(table).toContain("AGENT");
-    expect(table).toContain("aex_1");
-    expect(table).toContain("in-progress");
-  });
-});
-
-describe("formatAgentPhase", () => {
-  it.each([
-    [ExecutionPhase.EXECUTION_PENDING, "pending"],
-    [ExecutionPhase.EXECUTION_IN_PROGRESS, "running"],
-    [ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL, "awaiting-approval"],
-    [ExecutionPhase.EXECUTION_PAUSED, "paused"],
-    [ExecutionPhase.EXECUTION_COMPLETED, "completed"],
-    [ExecutionPhase.EXECUTION_FAILED, "failed"],
-    [ExecutionPhase.EXECUTION_CANCELLED, "cancelled"],
-    [ExecutionPhase.EXECUTION_TERMINATED, "terminated"],
-    [ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED, "unknown"],
-  ])("%s -> %s", (phase, expected) => {
-    expect(formatAgentPhase(phase)).toBe(expected);
-  });
-});
-
-describe("formatWorkflowPhase", () => {
-  it.each([
-    [WorkflowExecutionPhase.EXECUTION_PENDING, "pending"],
-    [WorkflowExecutionPhase.EXECUTION_IN_PROGRESS, "running"],
-    [WorkflowExecutionPhase.EXECUTION_COMPLETED, "completed"],
-    [WorkflowExecutionPhase.EXECUTION_FAILED, "failed"],
-    [WorkflowExecutionPhase.EXECUTION_CANCELLED, "cancelled"],
-    [WorkflowExecutionPhase.EXECUTION_TERMINATED, "terminated"],
-    [WorkflowExecutionPhase.EXECUTION_PAUSED, "paused"],
-    [WorkflowExecutionPhase.EXECUTION_PHASE_UNSPECIFIED, "unknown"],
-  ])("%s -> %s", (phase, expected) => {
-    expect(formatWorkflowPhase(phase)).toBe(expected);
-  });
-});
-
-describe("isTerminalAgentPhase", () => {
-  it.each([
-    [ExecutionPhase.EXECUTION_COMPLETED, true],
-    [ExecutionPhase.EXECUTION_FAILED, true],
-    [ExecutionPhase.EXECUTION_CANCELLED, true],
-    [ExecutionPhase.EXECUTION_TERMINATED, true],
-    [ExecutionPhase.EXECUTION_IN_PROGRESS, false],
-    [ExecutionPhase.EXECUTION_PAUSED, false],
-    [ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL, false],
-  ])("%s -> %s", (phase, expected) => {
-    expect(isTerminalAgentPhase(phase)).toBe(expected);
-  });
-});

package/src/resources/ignore/ignore.test.ts

@@ -1,62 +0,0 @@
-// The CLI's ignore edge: `createMatcher` reads `.gitignore` and
-// `.stigmerignore` from the directory and builds the shared engine's matcher
-// from their text. The engine's own tables (patterns, precedence,
-// last-match-wins) live with the engine in `@stigmer/plugin-package`; what is
-// pinned here is the disk reading — which files, honouring `respectGitignore`,
-// an absent file contributing nothing.
-
-import { 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 { createMatcher } from "./matcher.js";
-
-describe("createMatcher (the disk edge over the shared engine)", () => {
-  let dir: string;
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "ignore-test-"));
-  });
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("applies the security defaults with no ignore files present", () => {
-    const m = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
-    expect(m.match(".env", false)).toBe(true);
-    expect(m.match(".env.example", false)).toBe(false);
-  });
-
-  it("reads .gitignore from the root when respected, and not otherwise", () => {
-    writeFileSync(join(dir, ".gitignore"), "*.draft\n!keep.draft\n");
-    const respected = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
-    expect(respected.match("notes.draft", false)).toBe(true);
-    expect(respected.match("keep.draft", false)).toBe(false);
-    const ignored = createMatcher({ rootDir: dir, respectGitignore: false, includeDefaults: true });
-    expect(ignored.match("notes.draft", false)).toBe(false);
-  });
-
-  it("always reads .stigmerignore, which outranks .gitignore", () => {
-    writeFileSync(join(dir, ".gitignore"), "!shared.draft\n");
-    writeFileSync(join(dir, ".stigmerignore"), "*.draft\n");
-    const m = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
-    expect(m.match("shared.draft", false)).toBe(true);
-  });
-
-  it("passes the CLI flags through", () => {
-    const m = createMatcher({
-      rootDir: dir,
-      respectGitignore: true,
-      includeDefaults: true,
-      extraIgnore: ["*.tmp"],
-      extraInclude: ["important.tmp"],
-    });
-    expect(m.match("scratch.tmp", false)).toBe(true);
-    expect(m.match("important.tmp", false)).toBe(false);
-  });
-
-  it("refuses a root that is not a directory", () => {
-    expect(() => createMatcher({ rootDir: "", respectGitignore: true, includeDefaults: true })).toThrow(
-      "rootDir is required",
-    );
-  });
-});

package/src/resources/mcp/placeholder-resolver.test.ts

@@ -1,71 +0,0 @@
-// Unit tests for the strict ${VAR} placeholder resolver.
-
-import { describe, expect, it } from "vitest";
-import { PlaceholderResolutionError, resolveHeaders, resolvePlaceholders } from "./placeholder-resolver.js";
-
-describe("resolvePlaceholders", () => {
-  it("returns a string with no placeholders unchanged", () => {
-    expect(resolvePlaceholders("/tmp/data.sqlite", {})).toBe("/tmp/data.sqlite");
-  });
-
-  it("resolves a single placeholder from the env map", () => {
-    expect(resolvePlaceholders("${DIR}", { DIR: "/home/me" })).toBe("/home/me");
-  });
-
-  it("resolves a placeholder embedded in surrounding text", () => {
-    expect(resolvePlaceholders("${DB_PATH}/data.sqlite", { DB_PATH: "/var/lib" })).toBe("/var/lib/data.sqlite");
-  });
-
-  it("resolves multiple and adjacent placeholders", () => {
-    expect(resolvePlaceholders("${A}${B}-${A}", { A: "x", B: "y" })).toBe("xy-x");
-  });
-
-  it("resolves to an empty string when the value is empty", () => {
-    // An empty-but-present value is a resolved value, not a missing variable.
-    expect(resolvePlaceholders("[${X}]", { X: "" })).toBe("[]");
-  });
-
-  it("ignores $VAR without braces (only ${VAR} is a placeholder)", () => {
-    expect(resolvePlaceholders("$HOME/bin", { HOME: "/root" })).toBe("$HOME/bin");
-  });
-
-  it("throws PlaceholderResolutionError for an unresolved variable, carrying name + context", () => {
-    let caught: unknown;
-    try {
-      resolvePlaceholders("${MISSING}", { OTHER: "1" }, "stdio arg[2]");
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PlaceholderResolutionError);
-    const e = caught as PlaceholderResolutionError;
-    expect(e.variableName).toBe("MISSING");
-    expect(e.context).toBe("stdio arg[2]");
-    expect(e.message).toContain("${MISSING}");
-    expect(e.message).toContain("stdio arg[2]");
-  });
-
-  it("throws on the first unresolved variable even when others resolve", () => {
-    expect(() => resolvePlaceholders("${A}-${B}", { A: "ok" })).toThrow(PlaceholderResolutionError);
-  });
-});
-
-describe("resolveHeaders", () => {
-  it("resolves placeholders in every header value", () => {
-    const resolved = resolveHeaders(
-      { Authorization: "Bearer ${TOKEN}", "X-Static": "v1" },
-      { TOKEN: "abc123" },
-    );
-    expect(resolved).toEqual({ Authorization: "Bearer abc123", "X-Static": "v1" });
-  });
-
-  it("throws with the offending header name in the context", () => {
-    let caught: unknown;
-    try {
-      resolveHeaders({ Authorization: "Bearer ${API_KEY}" }, {});
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PlaceholderResolutionError);
-    expect((caught as PlaceholderResolutionError).message).toContain('header "Authorization"');
-  });
-});

package/src/resources/mcp/runtime-env.test.ts

@@ -1,102 +0,0 @@
-// Unit tests for shared MCP runtime_env construction.
-
-import { create } from "@bufbuild/protobuf";
-import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { UsageError } from "../../errors/index.js";
-import { buildRuntimeEnv, mergeProcessEnv, parseEnvOverrides, resolveDeclaredEnvValues } from "./runtime-env.js";
-
-function serverWithEnv(env: Record<string, { isSecret: boolean }>) {
-  return create(McpServerSchema, { metadata: { id: "mcp_1" }, spec: { env } });
-}
-
-// resolveDeclaredEnvValues takes the raw declarations map; the tests only rely on
-// keys being present, so a minimal declaration object is sufficient.
-function decls(...keys: string[]) {
-  return Object.fromEntries(keys.map((k) => [k, { isSecret: false }]));
-}
-
-describe("parseEnvOverrides", () => {
-  it("parses KEY=VALUE pairs, preserving '=' in the value", () => {
-    expect(parseEnvOverrides(["A=1", "B=x=y"])).toEqual({ A: "1", B: "x=y" });
-  });
-
-  it("throws a usage error on an entry without '='", () => {
-    expect(() => parseEnvOverrides(["BROKEN"])).toThrow(UsageError);
-  });
-
-  it("throws when the key is empty", () => {
-    expect(() => parseEnvOverrides(["=value"])).toThrow(UsageError);
-  });
-});
-
-describe("buildRuntimeEnv", () => {
-  const original = process.env;
-  beforeEach(() => {
-    process.env = { ...original, GITHUB_TOKEN: "from-os", PLANTON_API_KEY: "" };
-  });
-  afterEach(() => {
-    process.env = original;
-  });
-
-  it("pulls declared keys from the OS environment with their secret flag", () => {
-    const env = buildRuntimeEnv(serverWithEnv({ GITHUB_TOKEN: { isSecret: true } }));
-    expect(env.GITHUB_TOKEN.value).toBe("from-os");
-    expect(env.GITHUB_TOKEN.isSecret).toBe(true);
-  });
-
-  it("skips declared keys that are unset or empty in the environment", () => {
-    const env = buildRuntimeEnv(serverWithEnv({ PLANTON_API_KEY: { isSecret: true }, MISSING: { isSecret: false } }));
-    expect(env.PLANTON_API_KEY).toBeUndefined();
-    expect(env.MISSING).toBeUndefined();
-  });
-
-  it("lets --env overrides win over the OS environment", () => {
-    const env = buildRuntimeEnv(serverWithEnv({ GITHUB_TOKEN: { isSecret: true } }), ["GITHUB_TOKEN=override"]);
-    expect(env.GITHUB_TOKEN.value).toBe("override");
-    // is_secret is carried from the declaration.
-    expect(env.GITHUB_TOKEN.isSecret).toBe(true);
-  });
-
-  it("treats an override for an undeclared key as non-secret", () => {
-    const env = buildRuntimeEnv(serverWithEnv({}), ["EXTRA=1"]);
-    expect(env.EXTRA.value).toBe("1");
-    expect(env.EXTRA.isSecret).toBe(false);
-  });
-});
-
-describe("mergeProcessEnv", () => {
-  it("overlays overrides on top of process.env", () => {
-    const merged = mergeProcessEnv(["PATH=/custom", "NEW=1"]);
-    expect(merged.PATH).toBe("/custom");
-    expect(merged.NEW).toBe("1");
-  });
-});
-
-describe("resolveDeclaredEnvValues", () => {
-  const original = process.env;
-  beforeEach(() => {
-    process.env = { ...original, ALLOWED_DIR: "/from-os", EMPTY_VAR: "" };
-  });
-  afterEach(() => {
-    process.env = original;
-  });
-
-  it("pulls declared keys from the OS environment", () => {
-    expect(resolveDeclaredEnvValues(decls("ALLOWED_DIR"))).toEqual({ ALLOWED_DIR: "/from-os" });
-  });
-
-  it("skips declared keys that are unset or empty in the environment", () => {
-    expect(resolveDeclaredEnvValues(decls("EMPTY_VAR", "MISSING"))).toEqual({});
-  });
-
-  it("lets --env overrides win over the OS environment", () => {
-    expect(resolveDeclaredEnvValues(decls("ALLOWED_DIR"), ["ALLOWED_DIR=/override"])).toEqual({
-      ALLOWED_DIR: "/override",
-    });
-  });
-
-  it("includes an --env override even when the key is undeclared (matches buildRuntimeEnv)", () => {
-    expect(resolveDeclaredEnvValues(decls(), ["EXTRA=1"])).toEqual({ EXTRA: "1" });
-  });
-});