@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/task-analysis/types.ts

@@ -1,76 +1,60 @@
-export interface SourceLocation {
-  line: number;
-  column: number;
-}
-
-export interface Stage {
-  name: string;
-  order: number;
-  isAsync: boolean;
-}
-
-export interface ArtifactRead {
-  fileName: string;
-  stage: string;
-  required: boolean;
-}
+import { z } from "zod";
 
-export interface ArtifactWrite {
-  fileName: string;
-  stage: string;
-}
-
-export interface UnresolvedRead {
-  expression: string;
-  codeContext: string;
-  stage: string;
-  required: boolean;
-  location: SourceLocation;
-}
-
-export interface UnresolvedWrite {
-  expression: string;
-  codeContext: string;
-  stage: string;
-  location: SourceLocation;
-}
-
-export interface ModelCall {
-  provider: string;
-  method: string;
-  stage: string;
-}
-
-export interface ArtifactData {
-  reads: ArtifactRead[];
-  writes: ArtifactWrite[];
-  unresolvedReads: UnresolvedRead[];
-  unresolvedWrites: UnresolvedWrite[];
-}
+export type AnalysisStatus = "ok" | "unconfigured" | "error";
 
 export interface TaskAnalysis {
-  taskFilePath: string | null;
-  stages: Stage[];
-  artifacts: ArtifactData;
-  models: ModelCall[];
+  summary: string;
+  stages: { name: string; purpose: string }[];
+  artifacts: {
+    reads: { fileName: string; role: string }[];
+    writes: { fileName: string; role: string }[];
+  };
+  models: { provider: string; method: string; stage: string }[];
 }
 
 export interface PersistedTaskAnalysis extends TaskAnalysis {
   analyzedAt: string;
+  analysisStatus: AnalysisStatus;
+  analysisError?: string;
 }
 
+export const TaskAnalysisSchema = z.object({
+  summary: z.string(),
+  stages: z.array(
+    z.object({
+      name: z.string(),
+      purpose: z.string(),
+    }),
+  ),
+  artifacts: z.object({
+    reads: z.array(
+      z.object({
+        fileName: z.string(),
+        role: z.string(),
+      }),
+    ),
+    writes: z.array(
+      z.object({
+        fileName: z.string(),
+        role: z.string(),
+      }),
+    ),
+  }),
+  models: z.array(
+    z.object({
+      provider: z.string(),
+      method: z.string(),
+      stage: z.string(),
+    }),
+  ),
+});
+
 export interface DeducedSchema {
   schema: Record<string, unknown>;
   example: unknown;
   reasoning: string;
 }
 
-export interface ArtifactResolution {
-  resolvedFileName: string | null;
-  confidence: number;
-  reasoning: string;
-}
-
 export interface ArtifactDescriptor {
   fileName: string;
   stage: string;

package/src/ui/client/__tests__/api.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-import { decideGate, fetchConcurrencyStatus, restartJob, startTask, stopJob } from "../api";
+import { decideGate, fetchConcurrencyStatus, getJson, restartJob, startTask, stopJob } from "../api";
 import type { JobConcurrencyApiStatus } from "../types";
 
 const fetchMock = vi.fn<typeof fetch>();
@@ -177,4 +177,146 @@ describe("ui client api", () => {
       expect(fetchMock.mock.calls[0]?.[1]?.signal).toBe(controller.signal);
     });
   });
+
+  describe("getJson", () => {
+    it("returns unwrapped data on a 2xx {ok:true} response", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: true, data: { foo: "bar" } }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson<{ foo: string }>("/api/example")).resolves.toEqual({ foo: "bar" });
+    });
+
+    it("uses a provided validate guard as a type predicate", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: true, data: ["a", "b"] }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      const isStringArray = (value: unknown): value is string[] =>
+        Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+      await expect(getJson<string[]>("/api/lines", { validate: isStringArray })).resolves.toEqual([
+        "a",
+        "b",
+      ]);
+    });
+
+    it("throws a normalized ApiError on a non-2xx with a backend code", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ code: "job_running", message: "still running" }), {
+          status: 409,
+        }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson("/api/jobs/x/restart")).rejects.toMatchObject({
+        code: "job_running",
+        message: "still running",
+        status: 409,
+      });
+    });
+
+    it("falls back to the status default message on a non-2xx without a backend message", async () => {
+      fetchMock.mockResolvedValue(new Response("", { status: 500 }));
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson("/api/example")).rejects.toMatchObject({
+        code: "unknown_error",
+        message: "The server failed to process the request",
+        status: 500,
+      });
+    });
+
+    it("throws malformed_response on a 2xx {ok:false} envelope", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: false, error: "nope" }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(
+        getJson("/api/example", { malformedMessage: "Custom malformed message" }),
+      ).rejects.toMatchObject({
+        code: "malformed_response",
+        message: "Custom malformed message",
+        status: 200,
+      });
+    });
+
+    it("throws malformed_response on a 2xx envelope missing data", async () => {
+      fetchMock.mockResolvedValue(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson("/api/example")).rejects.toMatchObject({
+        code: "malformed_response",
+        status: 200,
+      });
+    });
+
+    it("throws malformed_response when validate rejects the data shape", async () => {
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: true, data: 42 }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(
+        getJson("/api/lines", { validate: Array.isArray as (value: unknown) => value is unknown[] }),
+      ).rejects.toMatchObject({ code: "malformed_response", status: 200 });
+    });
+
+    it("maps a fetch rejection to network_error", async () => {
+      fetchMock.mockRejectedValue(new Error("offline"));
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson("/api/example")).rejects.toMatchObject({
+        code: "network_error",
+        message: "offline",
+      });
+    });
+
+    it("propagates AbortError unchanged when fetch rejects with one", async () => {
+      fetchMock.mockRejectedValue(new DOMException("Aborted", "AbortError"));
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      const promise = getJson("/api/example");
+      await expect(promise).rejects.toBeInstanceOf(DOMException);
+      await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+    });
+
+    it("throws AbortError before fetching when the signal is already aborted", async () => {
+      const controller = new AbortController();
+      controller.abort();
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      const promise = getJson("/api/example", { signal: controller.signal });
+      await expect(promise).rejects.toBeInstanceOf(DOMException);
+      await expect(promise).rejects.toMatchObject({ name: "AbortError" });
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it("parses a concurrency fixture through the shared getJson path", async () => {
+      const sampleStatus: JobConcurrencyApiStatus = {
+        limit: 3,
+        runningCount: 1,
+        availableSlots: 2,
+        queuedCount: 1,
+        activeJobs: [
+          { jobId: "job-1", pid: 1234, acquiredAt: "2024-01-01T00:00:00Z", source: "orchestrator" },
+        ],
+        queuedJobs: [
+          { jobId: "job-2", queuedAt: "2024-01-01T00:00:01Z", name: "second", pipeline: "demo" },
+        ],
+        staleSlots: [],
+      };
+      fetchMock.mockResolvedValue(
+        new Response(JSON.stringify({ ok: true, data: sampleStatus }), { status: 200 }),
+      );
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      await expect(getJson<JobConcurrencyApiStatus>("/api/concurrency")).resolves.toEqual(
+        sampleStatus,
+      );
+    });
+  });
 });

package/src/ui/client/__tests__/bootstrap.test.ts

@@ -1,106 +1,222 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, spyOn } from "bun:test";
 
 import { bootstrap } from "../bootstrap";
 
 const originalFetch = globalThis.fetch;
-const originalEventSource = globalThis.EventSource;
+const originalEventSource = (globalThis as { EventSource?: unknown }).EventSource;
+const originalWarn = console.warn;
+
+type RecordedListener = [name: string, listener: EventListener];
 
 class MockEventSource {
-  public readonly addEventListener = vi.fn();
+  public static instances: MockEventSource[] = [];
+  public readonly addEventListenerCalls: RecordedListener[] = [];
+
+  public readonly addEventListener = (name: string, listener: EventListener): void => {
+    this.addEventListenerCalls.push([name, listener]);
+  };
+
+  constructor(public readonly url: string) {
+    MockEventSource.instances.push(this);
+  }
+}
 
-  constructor(public readonly url: string) {}
+function makeResponse(body: string, status = 200): Response {
+  return new Response(body, { status });
 }
 
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  if (originalEventSource === undefined) {
+    delete (globalThis as { EventSource?: unknown }).EventSource;
+  } else {
+    (globalThis as { EventSource?: unknown }).EventSource = originalEventSource;
+  }
+  console.warn = originalWarn;
+  MockEventSource.instances.length = 0;
+});
+
 describe("bootstrap", () => {
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    globalThis.EventSource = originalEventSource;
-    vi.restoreAllMocks();
+  it("applies the snapshot before opening the event source", async () => {
+    let callOrder = 0;
+    let snapshotOrder = 0;
+    let eventSourceOrder = 0;
+    const applySnapshot = (_snapshot: unknown): Promise<void> => {
+      callOrder += 1;
+      snapshotOrder = callOrder;
+      return Promise.resolve();
+    };
+    (globalThis as { EventSource?: unknown }).EventSource = function CountingEventSource(
+      this: unknown,
+      url: string,
+    ): MockEventSource {
+      callOrder += 1;
+      eventSourceOrder = callOrder;
+      void this;
+      void url;
+      return new MockEventSource(url);
+    };
+    globalThis.fetch = (() =>
+      Promise.resolve(
+        makeResponse(JSON.stringify({ ok: true, data: { state: "ready" } })),
+      )) as unknown as typeof fetch;
+
+    await bootstrap({ applySnapshot });
+
+    expect(snapshotOrder).toBe(1);
+    expect(eventSourceOrder).toBe(2);
+    expect(snapshotOrder).toBeLessThan(eventSourceOrder);
   });
 
-  it("applies the snapshot before opening the event source", async () => {
-    const applySnapshot = vi.fn(async () => undefined);
-    const eventSourceCtor = vi.fn((url: string) => new MockEventSource(url));
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify({ ok: true }), { status: 200 }),
-    ) as unknown as typeof fetch;
-    globalThis.EventSource = eventSourceCtor as unknown as typeof EventSource;
+  it("passes the unwrapped snapshot data to applySnapshot on a 2xx {ok:true} response", async () => {
+    const calls: Array<[unknown]> = [];
+    const applySnapshot = (snapshot: unknown) => {
+      calls.push([snapshot]);
+    };
+    globalThis.fetch = (() =>
+      Promise.resolve(
+        makeResponse(JSON.stringify({ ok: true, data: { state: "ready", jobs: [] } })),
+      )) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
 
     await bootstrap({ applySnapshot });
 
-    expect(applySnapshot).toHaveBeenCalledWith({ ok: true });
-    expect(eventSourceCtor).toHaveBeenCalledTimes(1);
-    const applyOrder = applySnapshot.mock.invocationCallOrder[0];
-    const eventSourceOrder = eventSourceCtor.mock.invocationCallOrder[0];
-    expect(applyOrder).toBeDefined();
-    expect(eventSourceOrder).toBeDefined();
-    expect(applyOrder!).toBeLessThan(eventSourceOrder!);
+    expect(calls).toEqual([[{ state: "ready", jobs: [] }]]);
   });
 
-  it("calls applySnapshot(null) on fetch failure and still returns an event source", async () => {
-    const applySnapshot = vi.fn();
-    const instance = new MockEventSource("/api/events");
-    globalThis.fetch = vi.fn<typeof fetch>().mockRejectedValue(new Error("offline")) as unknown as typeof fetch;
-    globalThis.EventSource = vi.fn(() => instance) as unknown as typeof EventSource;
+  it("degrades to applySnapshot(null) and warns once on a non-2xx response", async () => {
+    const calls: Array<[unknown]> = [];
+    const applySnapshot = (snapshot: unknown) => {
+      calls.push([snapshot]);
+    };
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => undefined);
+    globalThis.fetch = (() =>
+      Promise.resolve(makeResponse(JSON.stringify({ error: "bad" }), 500))) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
 
     const result = await bootstrap({ applySnapshot });
 
-    expect(applySnapshot).toHaveBeenCalledWith(null);
-    expect(result).toBe(instance);
+    expect(calls).toEqual([[null]]);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith(
+      "bootstrap: failed to load initial state",
+      expect.objectContaining({ code: "unknown_error", status: 500 }),
+    );
+    expect(result).toBeInstanceOf(MockEventSource);
   });
 
-  it("passes through non-ok json responses", async () => {
-    const applySnapshot = vi.fn();
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify({ error: "bad" }), { status: 500 }),
-    ) as unknown as typeof fetch;
-    globalThis.EventSource = vi.fn((url: string) => new MockEventSource(url)) as unknown as typeof EventSource;
+  it("degrades to applySnapshot(null) and warns once on a 2xx malformed envelope", async () => {
+    const calls: Array<[unknown]> = [];
+    const applySnapshot = (snapshot: unknown) => {
+      calls.push([snapshot]);
+    };
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => undefined);
+    globalThis.fetch = (() =>
+      Promise.resolve(makeResponse(JSON.stringify({ ok: false })))) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
 
-    await bootstrap({ applySnapshot });
+    const result = await bootstrap({ applySnapshot });
 
-    expect(applySnapshot).toHaveBeenCalledWith({ error: "bad" });
+    expect(calls).toEqual([[null]]);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith(
+      "bootstrap: failed to load initial state",
+      expect.objectContaining({ code: "malformed_response" }),
+    );
+    expect(result).toBeInstanceOf(MockEventSource);
   });
 
-  it("passes null for unparseable responses", async () => {
-    const applySnapshot = vi.fn();
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response("oops", { status: 500 }),
-    ) as unknown as typeof fetch;
-    globalThis.EventSource = vi.fn((url: string) => new MockEventSource(url)) as unknown as typeof EventSource;
+  it("degrades to applySnapshot(null) and warns once on a fetch rejection", async () => {
+    const calls: Array<[unknown]> = [];
+    const applySnapshot = (snapshot: unknown) => {
+      calls.push([snapshot]);
+    };
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => undefined);
+    globalThis.fetch = (() => Promise.reject(new Error("offline"))) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
 
-    await bootstrap({ applySnapshot });
+    const result = await bootstrap({ applySnapshot });
 
-    expect(applySnapshot).toHaveBeenCalledWith(null);
+    expect(calls).toEqual([[null]]);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith(
+      "bootstrap: failed to load initial state",
+      expect.objectContaining({ code: "network_error", message: "offline" }),
+    );
+    expect(result).toBeInstanceOf(MockEventSource);
+  });
+
+  it("degrades to applySnapshot(null) without warning on an unparseable non-2xx body", async () => {
+    const calls: Array<[unknown]> = [];
+    const applySnapshot = (snapshot: unknown) => {
+      calls.push([snapshot]);
+    };
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => undefined);
+    globalThis.fetch = (() =>
+      Promise.resolve(makeResponse("oops", 500))) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
+
+    const result = await bootstrap({ applySnapshot });
+
+    expect(calls).toEqual([[null]]);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith(
+      "bootstrap: failed to load initial state",
+      expect.objectContaining({ code: "unknown_error", status: 500 }),
+    );
+    expect(result).toBeInstanceOf(MockEventSource);
   });
 
   it("returns null when event source construction fails", async () => {
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify({ ok: true }), { status: 200 }),
-    ) as unknown as typeof fetch;
-    globalThis.EventSource = vi.fn(() => {
+    globalThis.fetch = (() =>
+      Promise.resolve(
+        makeResponse(JSON.stringify({ ok: true, data: { state: "ready" } })),
+      )) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = function ThrowingEventSource(): never {
       throw new Error("boom");
-    }) as unknown as typeof EventSource;
+    };
 
     await expect(bootstrap()).resolves.toBeNull();
   });
 
-  it("registers all bootstrap event listeners", async () => {
-    const instance = new MockEventSource("/api/events");
-    globalThis.fetch = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(JSON.stringify({ ok: true }), { status: 200 }),
-    ) as unknown as typeof fetch;
-    globalThis.EventSource = vi.fn(() => instance) as unknown as typeof EventSource;
+  it("registers exactly the seven contract event names", async () => {
+    globalThis.fetch = (() =>
+      Promise.resolve(
+        makeResponse(JSON.stringify({ ok: true, data: { state: "ready" } })),
+      )) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
 
     await bootstrap();
 
-    expect(instance.addEventListener).toHaveBeenCalledTimes(6);
-    expect(instance.addEventListener.mock.calls.map(([name]) => name)).toEqual([
-      "state",
-      "job:updated",
+    const last = MockEventSource.instances.at(-1);
+    expect(last).toBeDefined();
+    const names = last?.addEventListenerCalls.map(([name]) => name) ?? [];
+    expect(last?.addEventListenerCalls).toHaveLength(7);
+    expect(names).toEqual([
+      "state:change",
+      "state:summary",
       "job:created",
+      "job:updated",
       "job:removed",
       "heartbeat",
-      "message",
+      "seed:uploaded",
     ]);
   });
-});
+
+  it("does not register legacy browser event names", async () => {
+    globalThis.fetch = (() =>
+      Promise.resolve(
+        makeResponse(JSON.stringify({ ok: true, data: { state: "ready" } })),
+      )) as unknown as typeof fetch;
+    (globalThis as { EventSource?: unknown }).EventSource = MockEventSource;
+
+    await bootstrap();
+
+    const last = MockEventSource.instances.at(-1);
+    const names = new Set(last?.addEventListenerCalls.map(([name]) => name) ?? []);
+    expect(names.has("task:updated")).toBe(false);
+    expect(names.has("status:changed")).toBe(false);
+    expect(names.has("message")).toBe(false);
+    expect(names.has("state")).toBe(false);
+  });
+});