p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/tests/setup/vercel-webhook-probe.test.ts

@@ -0,0 +1,78 @@
+import { createHmac } from "node:crypto";
+import { describe, expect, it, vi } from "vitest";
+import { runSignedWebhookProbe } from "../../src/setup/vercel-webhook-probe.js";
+
+const SECRET = "probe-secret";
+
+function signBody(rawBody: string): string {
+  return createHmac("sha256", SECRET).update(rawBody).digest("hex");
+}
+
+describe("runSignedWebhookProbe", () => {
+  it("passes when the route authenticates and ignores the event", async () => {
+    const fetchMock = vi.fn(async (_url, init) => {
+      const rawBody = String(init?.body ?? "");
+      return {
+        status: 200,
+        headers: { get: () => null },
+        json: async () => ({ accepted: false, reason: "ignored_event" }),
+      };
+    });
+
+    const result = await runSignedWebhookProbe({
+      webhookUrl: "https://bridge.vercel.app/api/linear-webhook",
+      secret: SECRET,
+      nowMs: 1_700_000_000_000,
+      fetchImpl: fetchMock as typeof fetch,
+    });
+
+    expect(result.passed).toBe(true);
+    expect(result.result).toBe("accepted_ignored");
+    expect(result.reason).toBe("ignored_event");
+    expect(JSON.stringify(result)).not.toContain(SECRET);
+    const [, init] = fetchMock.mock.calls[0] ?? [];
+    expect((init as RequestInit)?.headers).toMatchObject({
+      "linear-signature": signBody(String((init as RequestInit).body)),
+    });
+  });
+
+  it("fails on invalid_signature", async () => {
+    const fetchMock = vi.fn(async () => ({
+      status: 401,
+      headers: { get: () => null },
+      json: async () => ({ error: "invalid_signature" }),
+    }));
+
+    const result = await runSignedWebhookProbe({
+      webhookUrl: "https://bridge.vercel.app/api/linear-webhook",
+      secret: SECRET,
+      fetchImpl: fetchMock as typeof fetch,
+    });
+
+    expect(result.passed).toBe(false);
+    expect(result.result).toBe("auth_failed");
+    expect(result.reason).toBe("invalid_signature");
+  });
+
+  it("fails on Vercel protection redirect", async () => {
+    const fetchMock = vi.fn(async () => ({
+      status: 302,
+      headers: {
+        get: (name: string) =>
+          name.toLowerCase() === "location"
+            ? "https://vercel.com/sso-api?url=..."
+            : null,
+      },
+      json: async () => ({}),
+    }));
+
+    const result = await runSignedWebhookProbe({
+      webhookUrl: "https://bridge.vercel.app/api/linear-webhook",
+      secret: SECRET,
+      fetchImpl: fetchMock as typeof fetch,
+    });
+
+    expect(result.passed).toBe(false);
+    expect(result.result).toBe("protection_redirect");
+  });
+});

package/workspace-snapshot/files/tests/setup/workflow-install-merge-errors.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import {
+  blockedCategoryMessage,
+  classifyWorkflowInstallMergeRejection,
+} from "../../src/setup/workflow-install-merge-errors.js";
+import { GitHubApiError } from "../../src/github/client.js";
+
+describe("workflow-install-merge-errors", () => {
+  it("classifies permission denial", () => {
+    const result = classifyWorkflowInstallMergeRejection({
+      error: new GitHubApiError(403, "Resource not accessible by integration"),
+    });
+    expect(result.category).toBe("permission-denied");
+    expect(result.waiting).toBe(false);
+  });
+
+  it("classifies pending checks as waiting", () => {
+    const result = classifyWorkflowInstallMergeRejection({
+      error: new GitHubApiError(422, "Required status check is pending"),
+    });
+    expect(result.category).toBe("checks-pending");
+    expect(result.waiting).toBe(true);
+  });
+
+  it("classifies merge conflict", () => {
+    const result = classifyWorkflowInstallMergeRejection({
+      error: new GitHubApiError(409, "Head branch was modified"),
+      mergeableState: "dirty",
+    });
+    expect(result.category).toBe("merge-conflict");
+  });
+
+  it("exposes PM-readable blocked messages without secrets", () => {
+    const message = blockedCategoryMessage("unexpected-pr-content");
+    expect(message).toContain("unexpected");
+    expect(message).not.toMatch(/ghp_|Bearer /);
+  });
+});

package/workspace-snapshot/files/tests/validate-issue/report.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { formatValidationReport } from "../../src/validate/report.js";
+import type { IssueValidationResult } from "../../src/validate/types.js";
+
+function baseResult(
+  overrides: Partial<IssueValidationResult> = {},
+): IssueValidationResult {
+  return {
+    validForPlanning: true,
+    validForDirectImplementation: false,
+    intendedPhase: "implementation",
+    passesIntendedPhase: false,
+    targetRepo: "https://github.com/owner/example-target-app",
+    resolutionSource: "explicit",
+    parseErrors: [],
+    resolverError: null,
+    narrowIssue: false,
+    narrowFailureReason: "task length 300 exceeds 240 characters",
+    hasPlanningMarker: false,
+    planningMarkerMode: "file",
+    routingNotes: ["Recommended status should be Ready for Planning, not Ready for Build."],
+    repairInstructions: [
+      "Too broad for Ready for Build — narrow task/AC, set recommended status to Ready for Planning, or complete a planning run first.",
+    ],
+    ...overrides,
+  };
+}
+
+describe("formatValidationReport", () => {
+  it("includes intended phase and planning marker fields", () => {
+    const report = formatValidationReport(baseResult());
+
+    expect(report).toContain("# Issue Validation Report");
+    expect(report).toContain("- Intended phase: implementation");
+    expect(report).toContain("- Passes intended phase: no");
+    expect(report).toContain("- Planning marker present: n/a");
+    expect(report).toContain("## Parser errors");
+    expect(report).toContain("## Routing / status notes");
+    expect(report).toContain("## Repair instructions");
+    expect(report).toContain("Ready for Planning");
+  });
+
+  it("shows planning marker yes in issue mode", () => {
+    const report = formatValidationReport(
+      baseResult({
+        hasPlanningMarker: true,
+        planningMarkerMode: "issue",
+        validForDirectImplementation: true,
+        passesIntendedPhase: true,
+      }),
+    );
+
+    expect(report).toContain("- Planning marker present: yes");
+    expect(report).toContain("- Passes intended phase: yes");
+  });
+});

package/workspace-snapshot/files/tests/validate-issue/validate-issue.test.ts

@@ -0,0 +1,202 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadConfig } from "../../src/config/load-config.js";
+import type { HarnessConfig } from "../../src/config/types.js";
+import {
+  computeIssueValidation,
+  validateIssueFromFile,
+} from "../../src/validate/issue.js";
+
+const fixturesDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../fixtures/issues",
+);
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../..",
+);
+
+async function loadFixtureBody(name: string): Promise<string> {
+  const raw = await readFile(path.join(fixturesDir, name), "utf8");
+  const bodyMatch = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
+  return bodyMatch ? bodyMatch[1]! : raw;
+}
+
+const testConfig: HarnessConfig = {
+  version: 1,
+  orchestratorMarker: "harness-orchestrator-v1",
+  logDirectory: "runs",
+  repos: [
+    {
+      id: "target-app",
+      linearProjects: ["Example Target App"],
+      linearTeams: ["WES"],
+      targetRepo: "https://github.com/owner/example-target-app",
+      baseBranch: "main",
+      previewProvider: "vercel",
+    },
+    {
+      id: "harness",
+      linearProjects: ["Agentic Product Development Harness"],
+      targetRepo: "https://github.com/weston-uribe/agentic-product-development-harness",
+      baseBranch: "main",
+      previewProvider: "none",
+    },
+  ],
+  allowedTargetRepos: [
+    "https://github.com/owner/example-target-app",
+    "https://github.com/weston-uribe/agentic-product-development-harness",
+  ],
+};
+
+describe("validateIssueFromFile", () => {
+  it("validates valid-target-app for planning and direct implementation", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "valid-target-app.md"),
+      testConfig,
+    );
+
+    expect(result.validForPlanning).toBe(true);
+    expect(result.validForDirectImplementation).toBe(true);
+    expect(result.narrowIssue).toBe(true);
+    expect(result.hasPlanningMarker).toBe(false);
+    expect(result.targetRepo).toBe(
+      "https://github.com/owner/example-target-app",
+    );
+  });
+
+  it("fails planning for missing acceptance criteria", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "missing-acceptance-criteria.md"),
+      testConfig,
+    );
+
+    expect(result.validForPlanning).toBe(false);
+    expect(result.validForDirectImplementation).toBe(false);
+    expect(result.parseErrors.some((e) => e.includes("Acceptance criteria"))).toBe(
+      true,
+    );
+  });
+
+  it("fails both routes for unknown repo", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "unknown-repo.md"),
+      testConfig,
+    );
+
+    expect(result.validForPlanning).toBe(false);
+    expect(result.resolverError?.classification).toBe("unknown_repo_denied");
+  });
+
+  it("passes planning but fails direct implementation for broad issue", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "broad-for-direct-impl.md"),
+      testConfig,
+      "implementation",
+    );
+
+    expect(result.validForPlanning).toBe(true);
+    expect(result.validForDirectImplementation).toBe(false);
+    expect(result.passesIntendedPhase).toBe(false);
+    expect(
+      result.repairInstructions.some((line) =>
+        line.includes("Ready for Planning"),
+      ),
+    ).toBe(true);
+  });
+
+  it("resolves target repo from context line", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "context-target-repo.md"),
+      testConfig,
+    );
+
+    expect(result.validForPlanning).toBe(true);
+    expect(result.resolutionSource).toBe("explicit");
+  });
+
+  it("validates project-only fixture without target repo section", async () => {
+    const result = await validateIssueFromFile(
+      path.join(fixturesDir, "valid-project-only.md"),
+      testConfig,
+    );
+
+    expect(result.validForPlanning).toBe(true);
+    expect(result.resolutionSource).toBe("project");
+    expect(result.targetRepo).toBe(
+      "https://github.com/owner/example-target-app",
+    );
+    expect(result.routingNotes).toContain(
+      "Target repo derived from Linear project mapping.",
+    );
+  });
+});
+
+describe("computeIssueValidation intended phase", () => {
+  it("mirrors validForPlanning when intended phase is planning", async () => {
+    const body = await loadFixtureBody("valid-minimal.md");
+    const result = computeIssueValidation(
+      body,
+      { projectName: "Example Target App" },
+      testConfig,
+      { intendedPhase: "planning", planningMarkerMode: "file" },
+    );
+
+    expect(result.passesIntendedPhase).toBe(result.validForPlanning);
+    expect(result.passesIntendedPhase).toBe(true);
+  });
+
+  it("mirrors validForDirectImplementation when intended phase is implementation", async () => {
+    const body = await loadFixtureBody("valid-minimal.md");
+    const result = computeIssueValidation(
+      body,
+      { projectName: "Example Target App" },
+      testConfig,
+      { intendedPhase: "implementation", planningMarkerMode: "file" },
+    );
+
+    expect(result.passesIntendedPhase).toBe(result.validForDirectImplementation);
+    expect(result.passesIntendedPhase).toBe(true);
+  });
+
+  it("allows direct implementation when planning marker exists on broad issue", async () => {
+    const body = await loadFixtureBody("broad-for-direct-impl.md");
+    const result = computeIssueValidation(
+      body,
+      { projectName: "Example Target App" },
+      testConfig,
+      {
+        intendedPhase: "implementation",
+        hasPlanningMarker: true,
+        planningMarkerMode: "issue",
+      },
+    );
+
+    expect(result.validForDirectImplementation).toBe(true);
+    expect(result.hasPlanningMarker).toBe(true);
+    expect(result.passesIntendedPhase).toBe(true);
+  });
+
+  it("rejects direct implementation for broad file without marker", async () => {
+    const body = await loadFixtureBody("broad-for-direct-impl.md");
+    const result = computeIssueValidation(
+      body,
+      { projectName: "Example Target App" },
+      testConfig,
+      { intendedPhase: "implementation", planningMarkerMode: "file" },
+    );
+
+    expect(result.validForDirectImplementation).toBe(false);
+    expect(result.hasPlanningMarker).toBe(false);
+  });
+});
+
+describe("validateIssueFromLinear (mocked)", () => {
+  it("loads harness.config.json for integration-style config parse", async () => {
+    const config = await loadConfig(path.join(repoRoot, "harness.config.json"));
+    expect(config.allowedTargetRepos.length).toBeGreaterThan(0);
+  });
+});

package/workspace-snapshot/files/tests/webhook/dispatch-github.test.ts

@@ -0,0 +1,193 @@
+import { createHmac } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vitest";
+import {
+  buildRepositoryDispatchUrl,
+  dispatchRepositoryEvent,
+} from "../../src/webhook/dispatch-github.js";
+import { handleLinearWebhook } from "../../src/webhook/handle-linear-webhook.js";
+import {
+  buildHarnessRunArgs,
+  buildHarnessRunCommand,
+} from "../../src/webhook/workflow-command.js";
+
+const SECRET = "test-webhook-secret";
+const TOKEN = "ghp_test_token";
+
+function signBody(rawBody: string): string {
+  return createHmac("sha256", SECRET).update(rawBody).digest("hex");
+}
+
+describe("dispatchRepositoryEvent", () => {
+  it("posts repository_dispatch with expected payload", async () => {
+    const fetchMock = vi.fn(async () => new Response(null, { status: 204 }));
+
+    await dispatchRepositoryEvent({
+      token: TOKEN,
+      repository: "weston-uribe/agentic-product-development-harness",
+      eventType: "linear_issue_status_changed",
+      clientPayload: {
+        issueKey: "WES-20",
+        issueId: "id-1",
+        issueUrl: "https://linear.app/weston/issue/WES-20/test",
+        action: "update",
+        statusName: "Ready for Planning",
+        previousStatusName: "Backlog",
+        linearDeliveryId: "delivery-1",
+        linearWebhookId: "webhook-1",
+        receivedAt: "2026-07-07T17:50:00.000Z",
+      },
+      fetchImpl: fetchMock,
+    });
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe(
+      buildRepositoryDispatchUrl("weston-uribe/agentic-product-development-harness"),
+    );
+    expect(init.method).toBe("POST");
+    expect(init.headers).toMatchObject({
+      Authorization: `Bearer ${TOKEN}`,
+      Accept: "application/vnd.github+json",
+    });
+
+    const body = JSON.parse(String(init.body));
+    expect(body.event_type).toBe("linear_issue_status_changed");
+    expect(body.client_payload.issueKey).toBe("WES-20");
+  });
+
+  it("posts production_promoted repository_dispatch payload", async () => {
+    const fetchMock = vi.fn(async () => new Response(null, { status: 204 }));
+
+    await dispatchRepositoryEvent({
+      token: TOKEN,
+      repository: "weston-uribe/agentic-product-development-harness",
+      eventType: "production_promoted",
+      clientPayload: {
+        repo: "target-app",
+        productionBranch: "main",
+        sourceRepo: "owner/example-target-app",
+        after: "abc123def456",
+        ref: "refs/heads/main",
+        receivedAt: "2026-07-07T23:46:00.000Z",
+        githubRunId: "12345",
+      },
+      fetchImpl: fetchMock,
+    });
+
+    const body = JSON.parse(String(fetchMock.mock.calls[0]![1]!.body));
+    expect(body.event_type).toBe("production_promoted");
+    expect(body.client_payload.repo).toBe("target-app");
+    expect(body.client_payload.productionBranch).toBe("main");
+    expect(body.client_payload.after).toBe("abc123def456");
+  });
+
+  it("throws when GitHub dispatch fails", async () => {
+    const fetchMock = vi.fn(async () => new Response("nope", { status: 403 }));
+
+    await expect(
+      dispatchRepositoryEvent({
+        token: TOKEN,
+        repository: "weston-uribe/agentic-product-development-harness",
+        eventType: "linear_issue_status_changed",
+        clientPayload: {
+          issueKey: "WES-20",
+          issueId: null,
+          issueUrl: null,
+          action: "update",
+          statusName: "Ready for Planning",
+          previousStatusName: null,
+          linearDeliveryId: null,
+          linearWebhookId: null,
+          receivedAt: "2026-07-07T17:50:00.000Z",
+        },
+        fetchImpl: fetchMock,
+      }),
+    ).rejects.toThrow(/repository_dispatch failed/);
+  });
+});
+
+describe("handleLinearWebhook integration", () => {
+  it("dispatches for allowlisted status changes", async () => {
+    const fixturePath = path.join(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "../fixtures/webhook/issue-ready-for-planning.json",
+    );
+    const rawBody = readFileSync(fixturePath, "utf8");
+    const fetchMock = vi.fn(async () => new Response(null, { status: 204 }));
+
+    const result = await handleLinearWebhook({
+      method: "POST",
+      rawBody,
+      headerGetter: (name) => {
+        if (name === "linear-signature") return signBody(rawBody);
+        if (name === "linear-delivery") return "delivery-1";
+        if (name === "linear-event") return "Issue";
+        if (name === "linear-timestamp") return "1700000000000";
+        return null;
+      },
+      webhookSecret: SECRET,
+      dispatchToken: TOKEN,
+      nowMs: 1_700_000_000_000,
+      fetchImpl: fetchMock,
+    });
+
+    expect(result.status).toBe(200);
+    expect(result.body).toEqual({
+      accepted: true,
+      dispatched: true,
+      issueKey: "WES-20",
+    });
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
+
+  it("returns ignored_status without dispatching", async () => {
+    const fixturePath = path.join(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "../fixtures/webhook/issue-pm-review.json",
+    );
+    const rawBody = readFileSync(fixturePath, "utf8");
+    const fetchMock = vi.fn(async () => new Response(null, { status: 204 }));
+
+    const result = await handleLinearWebhook({
+      method: "POST",
+      rawBody,
+      headerGetter: (name) => {
+        if (name === "linear-signature") return signBody(rawBody);
+        if (name === "linear-delivery") return "delivery-2";
+        if (name === "linear-event") return "Issue";
+        if (name === "linear-timestamp") return "1700000000000";
+        return null;
+      },
+      webhookSecret: SECRET,
+      dispatchToken: TOKEN,
+      nowMs: 1_700_000_000_000,
+      fetchImpl: fetchMock,
+    });
+
+    expect(result.status).toBe(200);
+    expect(result.body).toEqual({ accepted: false, reason: "ignored_status" });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("workflow command construction", () => {
+  it("builds repository_dispatch harness command", () => {
+    expect(buildHarnessRunCommand("WES-20")).toBe(
+      "npm run harness:run -- --issue WES-20 --phase auto --json",
+    );
+  });
+
+  it("builds manual workflow_dispatch args", () => {
+    expect(buildHarnessRunArgs("WES-20", "planning")).toEqual([
+      "run",
+      "--issue",
+      "WES-20",
+      "--phase",
+      "planning",
+      "--json",
+    ]);
+  });
+});

package/workspace-snapshot/files/tests/webhook/extract-issue-key.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractIssueKey,
+  extractIssueKeyFromUrl,
+  validateIssueKeyTeam,
+} from "../../src/webhook/extract-issue-key.js";
+
+describe("extractIssueKeyFromUrl", () => {
+  it("extracts issue key from Linear URL", () => {
+    expect(
+      extractIssueKeyFromUrl("https://linear.app/weston/issue/WES-13/target-app-link"),
+    ).toBe("WES-13");
+  });
+
+  it("extracts issue key before hash fragment", () => {
+    expect(
+      extractIssueKeyFromUrl("https://linear.app/weston/issue/WES-13/foo#comment-1"),
+    ).toBe("WES-13");
+  });
+
+  it("returns null for invalid URLs", () => {
+    expect(extractIssueKeyFromUrl("https://example.com/issues/abc")).toBeNull();
+  });
+});
+
+describe("extractIssueKey", () => {
+  it("prefers data.identifier", () => {
+    expect(
+      extractIssueKey({
+        identifier: "WES-20",
+        payloadUrl: "https://linear.app/weston/issue/WES-99/other",
+        teamKey: "WES",
+      }),
+    ).toBe("WES-20");
+  });
+
+  it("falls back to URL when identifier is missing", () => {
+    expect(
+      extractIssueKey({
+        identifier: null,
+        payloadUrl: "https://linear.app/weston/issue/WES-21/other",
+        teamKey: "WES",
+      }),
+    ).toBe("WES-21");
+  });
+
+  it("rejects keys outside configured team prefix", () => {
+    expect(
+      extractIssueKey({
+        identifier: "LIN-1",
+        teamKey: "WES",
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("validateIssueKeyTeam", () => {
+  it("accepts matching team keys", () => {
+    expect(validateIssueKeyTeam("WES-13", "WES")).toBe(true);
+  });
+
+  it("accepts any key when team key is not configured", () => {
+    expect(validateIssueKeyTeam("LIN-1", null)).toBe(true);
+  });
+});