shipwright-cli 2.4.0 → 3.1.0

package/dashboard/src/components/charts/pipeline-rail.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from "vitest";
+import { renderPipelineSVG, renderDoraGrades } from "./pipeline-rail";
+import type { PipelineInfo } from "../../types/api";
+
+describe("renderPipelineSVG", () => {
+  it("renders SVG for an empty pipeline", () => {
+    const pipeline = { status: "pending" } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("<svg");
+    expect(svg).toContain("</svg>");
+    expect(svg).toContain("pipeline-svg");
+  });
+
+  it("renders completed stages with green fill", () => {
+    const pipeline = {
+      stagesDone: ["intake", "plan"],
+      stage: "build",
+      status: "running",
+    } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("#4ade80"); // green for completed
+    expect(svg).toContain("#00d4ff"); // cyan for active
+  });
+
+  it("renders failed pipeline with red fill", () => {
+    const pipeline = {
+      stagesDone: ["intake", "plan"],
+      stage: "build",
+      status: "failed",
+    } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("#f43f5e"); // red for failed
+  });
+
+  it("renders stage labels", () => {
+    const pipeline = {
+      stagesDone: [],
+      stage: "intake",
+      status: "running",
+    } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("intake");
+  });
+
+  it("renders connecting lines between stages", () => {
+    const pipeline = { status: "pending" } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("<line");
+  });
+
+  it("renders animation for active stage", () => {
+    const pipeline = {
+      stagesDone: [],
+      stage: "intake",
+      status: "running",
+    } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("animate");
+    expect(svg).toContain("stage-node-active");
+  });
+
+  it("uses dashed lines for incomplete connections", () => {
+    const pipeline = {
+      stagesDone: [],
+      stage: "intake",
+      status: "running",
+    } as PipelineInfo;
+    const svg = renderPipelineSVG(pipeline);
+    expect(svg).toContain("stroke-dasharray");
+  });
+});
+
+describe("renderDoraGrades", () => {
+  it("returns empty string for null dora", () => {
+    expect(renderDoraGrades(null)).toBe("");
+  });
+
+  it("returns empty string for undefined dora", () => {
+    expect(renderDoraGrades(undefined)).toBe("");
+  });
+
+  it("renders DORA metrics cards", () => {
+    const dora = {
+      deploy_freq: { grade: "Elite", value: 7.5, unit: "/week" },
+      lead_time: { grade: "High", value: 2.1, unit: "hours" },
+      cfr: { grade: "Medium", value: 15.0, unit: "%" },
+      mttr: { grade: "Low", value: 24.0, unit: "hours" },
+    };
+    const html = renderDoraGrades(dora);
+    expect(html).toContain("dora-grades-row");
+    expect(html).toContain("Deploy Frequency");
+    expect(html).toContain("Lead Time");
+    expect(html).toContain("Change Failure Rate");
+    expect(html).toContain("Mean Time to Recovery");
+    expect(html).toContain("Elite");
+    expect(html).toContain("dora-elite");
+    expect(html).toContain("7.5");
+    expect(html).toContain("/week");
+  });
+
+  it("handles missing metrics gracefully", () => {
+    const dora = {
+      deploy_freq: { grade: "Elite", value: 5.0, unit: "/week" },
+    };
+    const html = renderDoraGrades(dora);
+    expect(html).toContain("Deploy Frequency");
+    expect(html).not.toContain("Lead Time");
+  });
+
+  it("handles null value with dash", () => {
+    const dora = {
+      cfr: { grade: "N/A", value: null as unknown as number, unit: "%" },
+    };
+    const html = renderDoraGrades(dora);
+    expect(html).toContain("\u2014");
+  });
+});

package/dashboard/src/components/charts/sparkline.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from "vitest";
+import { renderSparkline, renderSVGLineChart } from "./sparkline";
+
+describe("sparkline", () => {
+  describe("renderSparkline", () => {
+    it("returns empty string for empty data", () => {
+      expect(renderSparkline([], "#fff", 100, 40)).toBe("");
+    });
+
+    it("returns empty string for single point", () => {
+      expect(renderSparkline([5], "#fff", 100, 40)).toBe("");
+      expect(renderSparkline([{ value: 10 }], "#fff", 100, 40)).toBe("");
+    });
+
+    it("returns empty string for null/undefined points", () => {
+      expect(
+        renderSparkline(null as unknown as number[], "#fff", 100, 40),
+      ).toBe("");
+    });
+
+    it("returns SVG with path for multiple points (number array)", () => {
+      const svg = renderSparkline([10, 20, 30, 40], "#00d4ff", 100, 40);
+      expect(svg).toContain('<svg class="sparkline"');
+      expect(svg).toContain('viewBox="0 0 100 40"');
+      expect(svg).toContain("<path");
+      expect(svg).toContain('stroke="#00d4ff"');
+      expect(svg).toContain('stroke-width="1.5"');
+      expect(svg).toContain('fill="none"');
+      expect(svg).toContain("d=");
+      expect(svg).toMatch(/M[\d.]+,[\d.]+ L[\d.]+,[\d.]+/);
+    });
+
+    it("returns SVG with path for object array with value property", () => {
+      const svg = renderSparkline(
+        [{ value: 5 }, { value: 15 }, { value: 25 }],
+        "#7c3aed",
+        80,
+        32,
+      );
+      expect(svg).toContain('<svg class="sparkline"');
+      expect(svg).toContain("<path");
+      expect(svg).toContain('stroke="#7c3aed"');
+    });
+
+    it("handles object values with missing value (treats as 0)", () => {
+      const svg = renderSparkline([{ value: 0 }, { value: 0 }], "#333", 50, 20);
+      expect(svg).toContain('<svg class="sparkline"');
+      expect(svg).toContain("<path");
+    });
+
+    it("uses correct dimensions in output", () => {
+      const svg = renderSparkline([1, 2, 3], "#000", 200, 60);
+      expect(svg).toContain('width="200"');
+      expect(svg).toContain('height="60"');
+    });
+  });
+
+  describe("renderSVGLineChart", () => {
+    it("returns empty-state div for empty points", () => {
+      const out = renderSVGLineChart([], "value", "#00d4ff", 100, 40);
+      expect(out).toContain('<div class="empty-state">');
+      expect(out).toContain("Not enough data");
+    });
+
+    it("returns empty-state div for single point", () => {
+      const out = renderSVGLineChart(
+        [{ value: 10 }],
+        "value",
+        "#00d4ff",
+        100,
+        40,
+      );
+      expect(out).toContain('<div class="empty-state">');
+      expect(out).toContain("Not enough data");
+    });
+
+    it("returns empty-state for null/undefined points", () => {
+      const out = renderSVGLineChart(
+        null as unknown as Record<string, number>[],
+        "value",
+        "#00d4ff",
+        100,
+        40,
+      );
+      expect(out).toContain("Not enough data");
+    });
+
+    it("returns SVG with path and grid lines for multiple points", () => {
+      const points = [
+        { value: 10 },
+        { value: 30 },
+        { value: 20 },
+        { value: 50 },
+      ];
+      const svg = renderSVGLineChart(points, "value", "#4ade80", 300, 120);
+      expect(svg).toContain('<svg class="svg-line-chart"');
+      expect(svg).toContain('viewBox="0 0 300 120"');
+      expect(svg).toContain("<path");
+      expect(svg).toContain('stroke="#4ade80"');
+      expect(svg).toContain("<line");
+      expect(svg).toContain('stroke="#1a3a6a"');
+    });
+
+    it("uses custom valueKey when provided", () => {
+      const points = [{ count: 5 }, { count: 15 }, { count: 25 }];
+      const svg = renderSVGLineChart(points, "count", "#ff0000", 200, 80);
+      expect(svg).toContain('<svg class="svg-line-chart"');
+      expect(svg).toContain("<path");
+      expect(svg).toContain('stroke="#ff0000"');
+    });
+
+    it("falls back to value when valueKey missing", () => {
+      const points = [{ value: 1 }, { value: 2 }];
+      const svg = renderSVGLineChart(points, "missing", "#000", 100, 50);
+      expect(svg).toContain("<path");
+    });
+
+    it("handles all-zero max (uses maxVal=1 to avoid div by zero)", () => {
+      const points = [{ value: 0 }, { value: 0 }];
+      const svg = renderSVGLineChart(points, "value", "#000", 100, 50);
+      expect(svg).toContain("<svg");
+      expect(svg).not.toContain("Not enough data");
+    });
+  });
+});

package/dashboard/src/core/api.test.ts

@@ -334,6 +334,315 @@ describe("API Client", () => {
     });
   });
 
+  describe("machine health check and join tokens", () => {
+    it("machineHealthCheck calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ machine: {} }));
+      await api.machineHealthCheck("node-1");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/machines/node-1/health-check",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+
+    it("fetchJoinTokens calls GET /api/join-token", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ tokens: [] }));
+      await api.fetchJoinTokens();
+      expect(mockFetch).toHaveBeenCalledWith("/api/join-token", undefined);
+    });
+
+    it("generateJoinToken calls POST /api/join-token", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ join_cmd: "sw join ..." }));
+      await api.generateJoinToken({ label: "test", max_workers: 4 });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/join-token",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("costs", () => {
+    it("fetchCostBreakdown defaults to 7 day period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchCostBreakdown();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/costs/breakdown?period=7",
+        undefined,
+      );
+    });
+
+    it("fetchCostTrend defaults to 30 day period", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ points: [] }));
+      await api.fetchCostTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/costs/trend?period=30",
+        undefined,
+      );
+    });
+  });
+
+  describe("daemon", () => {
+    it("fetchDaemonConfig calls GET /api/daemon/config", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDaemonConfig();
+      expect(mockFetch).toHaveBeenCalledWith("/api/daemon/config", undefined);
+    });
+
+    it("daemonControl calls POST /api/daemon/:action", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.daemonControl("pause");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/daemon/pause",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("alerts and artifacts", () => {
+    it("fetchAlerts calls GET /api/alerts", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ alerts: [] }));
+      await api.fetchAlerts();
+      expect(mockFetch).toHaveBeenCalledWith("/api/alerts", undefined);
+    });
+
+    it("fetchArtifact calls correct endpoint", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ content: "..." }));
+      await api.fetchArtifact(42, "plan");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/artifacts/42/plan",
+        undefined,
+      );
+    });
+
+    it("fetchGitHubStatus calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchGitHubStatus(42);
+      expect(mockFetch).toHaveBeenCalledWith("/api/github/42", undefined);
+    });
+
+    it("fetchLogs calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ content: "log" }));
+      await api.fetchLogs(42);
+      expect(mockFetch).toHaveBeenCalledWith("/api/logs/42", undefined);
+    });
+  });
+
+  describe("metrics detail", () => {
+    it("fetchStagePerformance defaults to 7 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ stages: [] }));
+      await api.fetchStagePerformance();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/stage-performance?period=7",
+        undefined,
+      );
+    });
+
+    it("fetchBottlenecks calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ bottlenecks: [] }));
+      await api.fetchBottlenecks();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/bottlenecks",
+        undefined,
+      );
+    });
+
+    it("fetchThroughputTrend defaults to 30 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ points: [] }));
+      await api.fetchThroughputTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/throughput-trend?period=30",
+        undefined,
+      );
+    });
+
+    it("fetchCapacity calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ rate: 2, queue_clear_hours: 1 }),
+      );
+      await api.fetchCapacity();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/capacity",
+        undefined,
+      );
+    });
+
+    it("fetchDoraTrend defaults to 30 days", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDoraTrend();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/metrics/dora-trend?period=30",
+        undefined,
+      );
+    });
+  });
+
+  describe("team endpoints", () => {
+    it("fetchTeam calls GET /api/team", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchTeam();
+      expect(mockFetch).toHaveBeenCalledWith("/api/team", undefined);
+    });
+
+    it("fetchTeamActivity returns events array", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ events: [{ id: 1 }] }));
+      const result = await api.fetchTeamActivity();
+      expect(result).toEqual([{ id: 1 }]);
+    });
+
+    it("fetchTeamActivity returns empty array on error", async () => {
+      mockFetch.mockReturnValueOnce(errorResponse(500));
+      const result = await api.fetchTeamActivity();
+      expect(result).toEqual([]);
+    });
+
+    it("createTeamInvite calls POST /api/team/invite", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ token: "abc", url: "...", expires_at: "..." }),
+      );
+      await api.createTeamInvite({ expires_hours: 24 });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/team/invite",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  describe("pipeline test results and learnings", () => {
+    it("fetchPipelineTestResults calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchPipelineTestResults(42);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/42/test-results",
+        undefined,
+      );
+    });
+
+    it("fetchGlobalLearnings calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ learnings: [] }));
+      await api.fetchGlobalLearnings();
+      expect(mockFetch).toHaveBeenCalledWith("/api/memory/global", undefined);
+    });
+
+    it("fetchPatrol returns findings on success", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ findings: [{ id: 1 }] }));
+      const result = await api.fetchPatrol();
+      expect(result).toEqual({ findings: [{ id: 1 }] });
+    });
+  });
+
+  describe("integration and DB endpoints", () => {
+    it("fetchLinearStatus calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchLinearStatus();
+      expect(mockFetch).toHaveBeenCalledWith("/api/linear/status", undefined);
+    });
+
+    it("fetchDbEvents with defaults", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ events: [], source: "db" }));
+      await api.fetchDbEvents();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/db/events?since=0&limit=200",
+        undefined,
+      );
+    });
+
+    it("fetchDbJobs without status filter", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ jobs: [], source: "db" }));
+      await api.fetchDbJobs();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/jobs", undefined);
+    });
+
+    it("fetchDbJobs with status filter", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ jobs: [], source: "db" }));
+      await api.fetchDbJobs("active");
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/db/jobs?status=active",
+        undefined,
+      );
+    });
+
+    it("fetchDbCostsToday calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDbCostsToday();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/costs/today", undefined);
+    });
+
+    it("fetchDbHeartbeats calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ heartbeats: [], source: "db" }),
+      );
+      await api.fetchDbHeartbeats();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/heartbeats", undefined);
+    });
+
+    it("fetchDbHealth calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({}));
+      await api.fetchDbHealth();
+      expect(mockFetch).toHaveBeenCalledWith("/api/db/health", undefined);
+    });
+  });
+
+  describe("audit, quality gates, approvals, notifications", () => {
+    it("fetchAuditLog calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ entries: [] }));
+      await api.fetchAuditLog();
+      expect(mockFetch).toHaveBeenCalledWith("/api/audit-log", undefined);
+    });
+
+    it("fetchQualityGates calls GET", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ enabled: true, rules: [] }));
+      await api.fetchQualityGates();
+      expect(mockFetch).toHaveBeenCalledWith("/api/quality-gates", undefined);
+    });
+
+    it("fetchPipelineQuality calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ quality: {}, gates: {}, results: [] }),
+      );
+      await api.fetchPipelineQuality(42);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/pipeline/42/quality",
+        undefined,
+      );
+    });
+
+    it("fetchApprovalGates calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ enabled: true, stages: [], pending: [] }),
+      );
+      await api.fetchApprovalGates();
+      expect(mockFetch).toHaveBeenCalledWith("/api/approval-gates", undefined);
+    });
+
+    it("updateApprovalGates calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.updateApprovalGates({ enabled: true, stages: ["review"] });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/approval-gates",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+
+    it("fetchNotificationConfig calls GET", async () => {
+      mockFetch.mockReturnValueOnce(
+        jsonResponse({ enabled: true, webhooks: [] }),
+      );
+      await api.fetchNotificationConfig();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/notifications/config",
+        undefined,
+      );
+    });
+
+    it("testNotification calls POST", async () => {
+      mockFetch.mockReturnValueOnce(jsonResponse({ ok: true }));
+      await api.testNotification();
+      expect(mockFetch).toHaveBeenCalledWith(
+        "/api/notifications/test",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
   describe("error handling", () => {
     it("throws on non-ok response", async () => {
       mockFetch.mockReturnValueOnce(errorResponse(404, { error: "Not found" }));