@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/shared/src/__tests__/platform-git.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for packages/shared/src/platform/git.ts — Recipe argv shapes +
+ * light integration tests against the actual repository.
+ *
+ * The argv-shape tests are pure: they verify the Recipe's `argv()`
+ * function produces the expected command without spawning anything.
+ *
+ * The integration tests use the actual repo as a git fixture; they're
+ * smoke tests that the full recipe → runner → git pipeline works.
+ *
+ * See change: platform-command-executor.
+ */
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import url from "node:url";
+import {
+  GIT_DIFF,
+  GIT_STATUS_PORCELAIN,
+  GIT_IS_REPO,
+  GIT_CURRENT_BRANCH,
+  GIT_HEAD_SHA,
+  GIT_REMOTE_URL,
+  GH_PR_NUMBER,
+  GIT_RECIPES,
+  isGitRepo,
+  currentBranch,
+  headSha,
+  remoteUrl,
+  diff,
+  statusPorcelain,
+  isGitRepoOr,
+  currentBranchOr,
+} from "../platform/git.js";
+
+const here = path.dirname(url.fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(here, "..", "..", "..", "..");
+
+// ── Pure argv tests ─────────────────────────────────────────────────────────
+
+describe("GIT_DIFF.argv", () => {
+  it("produces `git diff HEAD -- <path>` by default", () => {
+    expect(GIT_DIFF.argv({ cwd: "/tmp", path: "src/foo.ts" })).toEqual([
+      "git", "diff", "HEAD", "--", "src/foo.ts",
+    ]);
+  });
+
+  it("respects an explicit ref", () => {
+    expect(GIT_DIFF.argv({ cwd: "/tmp", path: "a.ts", ref: "main" })).toEqual([
+      "git", "diff", "main", "--", "a.ts",
+    ]);
+  });
+
+  it("does not shell-escape the path (argv array is passed verbatim)", () => {
+    // With argv arrays, paths like "a b.ts" flow through as one element.
+    // No JSON.stringify, no quoting — safe by construction.
+    expect(GIT_DIFF.argv({ cwd: "/tmp", path: "a b.ts" })).toEqual([
+      "git", "diff", "HEAD", "--", "a b.ts",
+    ]);
+  });
+
+  it("tolerates exit code 1 (no-diff or empty repo)", () => {
+    expect(GIT_DIFF.tolerate).toContain(1);
+  });
+});
+
+describe("GIT_STATUS_PORCELAIN.argv", () => {
+  it("omits `--` when no path is given", () => {
+    expect(GIT_STATUS_PORCELAIN.argv({ cwd: "/tmp" })).toEqual([
+      "git", "status", "--porcelain",
+    ]);
+  });
+
+  it("adds `-- <path>` when a path is given", () => {
+    expect(GIT_STATUS_PORCELAIN.argv({ cwd: "/tmp", path: "src/foo.ts" })).toEqual([
+      "git", "status", "--porcelain", "--", "src/foo.ts",
+    ]);
+  });
+});
+
+describe("other recipe argv shapes", () => {
+  it("GIT_IS_REPO", () => {
+    expect(GIT_IS_REPO.argv({ cwd: "/tmp" })).toEqual(["git", "rev-parse", "--is-inside-work-tree"]);
+  });
+
+  it("GIT_CURRENT_BRANCH", () => {
+    expect(GIT_CURRENT_BRANCH.argv({ cwd: "/tmp" })).toEqual(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  });
+
+  it("GIT_HEAD_SHA (full)", () => {
+    expect(GIT_HEAD_SHA.argv({ cwd: "/tmp" })).toEqual(["git", "rev-parse", "HEAD"]);
+  });
+
+  it("GIT_HEAD_SHA (short)", () => {
+    expect(GIT_HEAD_SHA.argv({ cwd: "/tmp", short: true })).toEqual(["git", "rev-parse", "--short", "HEAD"]);
+  });
+
+  it("GIT_REMOTE_URL (default origin)", () => {
+    expect(GIT_REMOTE_URL.argv({ cwd: "/tmp" })).toEqual(["git", "remote", "get-url", "origin"]);
+  });
+
+  it("GIT_REMOTE_URL (custom remote)", () => {
+    expect(GIT_REMOTE_URL.argv({ cwd: "/tmp", remote: "upstream" })).toEqual([
+      "git", "remote", "get-url", "upstream",
+    ]);
+  });
+
+  it("GH_PR_NUMBER tolerates exit 1 (no PR)", () => {
+    expect(GH_PR_NUMBER.tolerate).toContain(1);
+    expect(GH_PR_NUMBER.argv({ cwd: "/tmp" })).toEqual([
+      "gh", "pr", "view", "--json", "number", "-q", ".number",
+    ]);
+  });
+});
+
+describe("GIT_RECIPES registry", () => {
+  it("enumerates all exported recipes", () => {
+    const keys = Object.keys(GIT_RECIPES).sort();
+    expect(keys).toEqual([
+      "GH_PR_NUMBER",
+      "GIT_CURRENT_BRANCH",
+      "GIT_DIFF",
+      "GIT_HEAD_SHA",
+      "GIT_IS_REPO",
+      "GIT_REMOTE_URL",
+      "GIT_STATUS_PORCELAIN",
+    ]);
+  });
+
+  it("every recipe has argv and parse functions", () => {
+    for (const [name, recipe] of Object.entries(GIT_RECIPES)) {
+      expect(typeof recipe.argv, `${name}.argv`).toBe("function");
+      expect(typeof recipe.parse, `${name}.parse`).toBe("function");
+    }
+  });
+});
+
+// ── Integration tests against the actual repository ────────────────────────
+
+describe("git.* integration (runs against this repo)", () => {
+  it("isGitRepo returns true for the repo root", () => {
+    const result = isGitRepo({ cwd: REPO_ROOT });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(result.value).toBe(true);
+  });
+
+  it("isGitRepoOr returns false for a non-repo directory", () => {
+    expect(isGitRepoOr({ cwd: require("node:os").tmpdir() })).toBe(false);
+  });
+
+  it("currentBranch returns a string for the repo", () => {
+    const result = currentBranch({ cwd: REPO_ROOT });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(typeof result.value).toBe("string");
+      expect(result.value!.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("headSha returns a 40-char SHA for the repo", () => {
+    const result = headSha({ cwd: REPO_ROOT });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(result.value).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  it("headSha short returns a 7-char SHA", () => {
+    const result = headSha({ cwd: REPO_ROOT, short: true });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(result.value).toMatch(/^[0-9a-f]{7}/);
+  });
+
+  it("remoteUrl returns a URL string if origin is set", () => {
+    // This repo has an origin remote; the value is non-empty.
+    const result = remoteUrl({ cwd: REPO_ROOT });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(result.value?.length ?? 0).toBeGreaterThan(0);
+  });
+
+  it("statusPorcelain returns a string (possibly empty)", () => {
+    const result = statusPorcelain({ cwd: REPO_ROOT });
+    expect(result.ok).toBe(true);
+    if (result.ok) expect(typeof result.value).toBe("string");
+  });
+
+  it("diff with exit-1 tolerance does not throw for a clean path", () => {
+    // Pick a file guaranteed to exist and typically be unchanged in test runs.
+    const result = diff({ cwd: REPO_ROOT, path: "package.json" });
+    // tolerate: [1] means no diff is still ok
+    expect(result.ok).toBe(true);
+  });
+
+  it("currentBranchOr returns a fallback when cwd is not a repo", () => {
+    expect(currentBranchOr({ cwd: require("node:os").tmpdir() }, "no-repo")).toBe("no-repo");
+  });
+});

package/packages/shared/src/__tests__/platform-npm.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for packages/shared/src/platform/npm.ts — Recipe argv + parse.
+ * Live npm calls are out of scope (npm may or may not be on PATH in CI).
+ *
+ * See change: platform-command-executor.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  NPM_ROOT_GLOBAL,
+  NPM_OUTDATED,
+  NPM_OUTDATED_GLOBAL,
+  NPM_INSTALL,
+  NPM_INSTALL_GLOBAL,
+  NPM_VIEW_VERSION,
+  NPM_RECIPES,
+  _resetNpmRootCache,
+} from "../platform/npm.js";
+
+beforeEach(() => {
+  _resetNpmRootCache();
+});
+
+describe("NPM_ROOT_GLOBAL", () => {
+  it("produces `npm root -g`", () => {
+    expect(NPM_ROOT_GLOBAL.argv({})).toEqual(["npm", "root", "-g"]);
+  });
+
+  it("trims stdout", () => {
+    expect(NPM_ROOT_GLOBAL.parse("/usr/lib/node_modules\n", {})).toBe("/usr/lib/node_modules");
+  });
+});
+
+describe("NPM_OUTDATED", () => {
+  it("project-wide form", () => {
+    expect(NPM_OUTDATED.argv({})).toEqual(["npm", "outdated", "--json"]);
+  });
+
+  it("scoped to a single package", () => {
+    expect(NPM_OUTDATED.argv({ pkg: "pi-web-access" })).toEqual([
+      "npm", "outdated", "pi-web-access", "--json",
+    ]);
+  });
+
+  it("parses JSON stdout", () => {
+    const json = '{"pi-flows":{"current":"1.0.0","wanted":"1.1.0"}}';
+    expect(NPM_OUTDATED.parse(json, {})).toEqual({
+      "pi-flows": { current: "1.0.0", wanted: "1.1.0" },
+    });
+  });
+
+  it("returns null for empty or malformed stdout", () => {
+    expect(NPM_OUTDATED.parse("", {})).toBeNull();
+    expect(NPM_OUTDATED.parse("not json", {})).toBeNull();
+  });
+
+  it("tolerates exit code 1 (npm exits 1 when updates exist)", () => {
+    expect(NPM_OUTDATED.tolerate).toContain(1);
+  });
+});
+
+describe("NPM_OUTDATED_GLOBAL", () => {
+  it("includes `-g` flag", () => {
+    expect(NPM_OUTDATED_GLOBAL.argv({})).toEqual(["npm", "outdated", "-g", "--json"]);
+  });
+
+  it("scoped form", () => {
+    expect(NPM_OUTDATED_GLOBAL.argv({ pkg: "typescript" })).toEqual([
+      "npm", "outdated", "-g", "typescript", "--json",
+    ]);
+  });
+
+  it("tolerates exit 1", () => {
+    expect(NPM_OUTDATED_GLOBAL.tolerate).toContain(1);
+  });
+});
+
+describe("NPM_INSTALL", () => {
+  it("installs latest when version omitted", () => {
+    expect(NPM_INSTALL.argv({ pkg: "pi-flows" })).toEqual(["npm", "install", "pi-flows"]);
+  });
+
+  it("installs pinned version", () => {
+    expect(NPM_INSTALL.argv({ pkg: "pi-flows", version: "1.2.3" })).toEqual([
+      "npm", "install", "pi-flows@1.2.3",
+    ]);
+  });
+
+  it("has a long timeout for install", () => {
+    expect(NPM_INSTALL.timeout).toBeGreaterThanOrEqual(60_000);
+  });
+});
+
+describe("NPM_INSTALL_GLOBAL", () => {
+  it("includes `-g` flag with version", () => {
+    expect(NPM_INSTALL_GLOBAL.argv({ pkg: "typescript", version: "5.0.0" })).toEqual([
+      "npm", "install", "-g", "typescript@5.0.0",
+    ]);
+  });
+
+  it("omits version suffix when not given", () => {
+    expect(NPM_INSTALL_GLOBAL.argv({ pkg: "typescript" })).toEqual([
+      "npm", "install", "-g", "typescript",
+    ]);
+  });
+});
+
+describe("NPM_VIEW_VERSION", () => {
+  it("produces `npm view <pkg> version`", () => {
+    expect(NPM_VIEW_VERSION.argv({ pkg: "@blackbelt-technology/pi-agent-dashboard" })).toEqual([
+      "npm", "view", "@blackbelt-technology/pi-agent-dashboard", "version",
+    ]);
+  });
+
+  it("trims the version string", () => {
+    expect(NPM_VIEW_VERSION.parse("1.2.3\n", { pkg: "x" })).toBe("1.2.3");
+  });
+});
+
+describe("NPM_RECIPES registry", () => {
+  it("enumerates all 6 recipes", () => {
+    expect(Object.keys(NPM_RECIPES).sort()).toEqual([
+      "NPM_INSTALL",
+      "NPM_INSTALL_GLOBAL",
+      "NPM_OUTDATED",
+      "NPM_OUTDATED_GLOBAL",
+      "NPM_ROOT_GLOBAL",
+      "NPM_VIEW_VERSION",
+    ]);
+  });
+
+  it("every recipe has argv and parse functions", () => {
+    for (const [name, recipe] of Object.entries(NPM_RECIPES)) {
+      expect(typeof recipe.argv, `${name}.argv`).toBe("function");
+      expect(typeof recipe.parse, `${name}.parse`).toBe("function");
+    }
+  });
+});

package/packages/shared/src/__tests__/platform-openspec.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for packages/shared/src/platform/openspec.ts.
+ *
+ * Pure argv + parse tests; integration with a live openspec binary is
+ * out of scope for unit tests (openspec may not be on PATH in CI).
+ *
+ * See change: platform-command-executor.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  OPENSPEC_LIST,
+  OPENSPEC_STATUS,
+  OPENSPEC_ARCHIVE_COMPLETED,
+  OPENSPEC_RECIPES,
+} from "../platform/openspec.js";
+
+describe("OPENSPEC_LIST", () => {
+  it("produces `openspec list --json`", () => {
+    expect(OPENSPEC_LIST.argv({ cwd: "/tmp" })).toEqual(["openspec", "list", "--json"]);
+  });
+
+  it("parses valid JSON output", () => {
+    const input = { cwd: "/tmp" };
+    const out = OPENSPEC_LIST.parse('{"changes":[{"name":"x"}]}', input);
+    expect(out).toEqual({ changes: [{ name: "x" }] });
+  });
+
+  it("returns null for empty stdout", () => {
+    expect(OPENSPEC_LIST.parse("", { cwd: "/tmp" })).toBeNull();
+    expect(OPENSPEC_LIST.parse("   \n", { cwd: "/tmp" })).toBeNull();
+  });
+
+  it("returns null for malformed JSON", () => {
+    expect(OPENSPEC_LIST.parse("not json", { cwd: "/tmp" })).toBeNull();
+    expect(OPENSPEC_LIST.parse("{broken", { cwd: "/tmp" })).toBeNull();
+  });
+});
+
+describe("OPENSPEC_STATUS", () => {
+  it("produces `openspec status --change <name> --json`", () => {
+    expect(OPENSPEC_STATUS.argv({ cwd: "/tmp", change: "add-feature" })).toEqual([
+      "openspec", "status", "--change", "add-feature", "--json",
+    ]);
+  });
+
+  it("parses status result JSON", () => {
+    const input = { cwd: "/tmp", change: "x" };
+    const out = OPENSPEC_STATUS.parse('{"artifacts":[{"id":"proposal","status":"done"}]}', input);
+    expect(out).toEqual({ artifacts: [{ id: "proposal", status: "done" }] });
+  });
+
+  it("accepts change names with special characters verbatim (no shell escaping needed)", () => {
+    // argv is an array, so special chars flow through unchanged
+    expect(OPENSPEC_STATUS.argv({ cwd: "/tmp", change: "a b/c" })).toEqual([
+      "openspec", "status", "--change", "a b/c", "--json",
+    ]);
+  });
+});
+
+describe("OPENSPEC_ARCHIVE_COMPLETED", () => {
+  it("produces `openspec archive --completed`", () => {
+    expect(OPENSPEC_ARCHIVE_COMPLETED.argv({ cwd: "/tmp" })).toEqual([
+      "openspec", "archive", "--completed",
+    ]);
+  });
+
+  it("returns stdout verbatim (no JSON parsing)", () => {
+    expect(OPENSPEC_ARCHIVE_COMPLETED.parse("Archived 3 changes\n", { cwd: "/tmp" }))
+      .toBe("Archived 3 changes\n");
+  });
+
+  it("has a longer timeout than list/status (archive can be slow)", () => {
+    expect(OPENSPEC_ARCHIVE_COMPLETED.timeout).toBeGreaterThanOrEqual(15_000);
+  });
+});
+
+describe("OPENSPEC_RECIPES registry", () => {
+  it("enumerates all exported recipes", () => {
+    expect(Object.keys(OPENSPEC_RECIPES).sort()).toEqual([
+      "OPENSPEC_ARCHIVE_COMPLETED",
+      "OPENSPEC_LIST",
+      "OPENSPEC_STATUS",
+    ]);
+  });
+
+  it("every recipe has argv and parse functions", () => {
+    for (const [name, recipe] of Object.entries(OPENSPEC_RECIPES)) {
+      expect(typeof recipe.argv, `${name}.argv`).toBe("function");
+      expect(typeof recipe.parse, `${name}.parse`).toBe("function");
+    }
+  });
+});