p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/tests/cli/doctor.test.ts

@@ -0,0 +1,120 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  pingLinear: vi.fn(),
+  pingGitHub: vi.fn(),
+}));
+
+vi.mock("../../src/linear/client.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/linear/client.js")>();
+  return {
+    ...actual,
+    pingLinear: mocks.pingLinear,
+  };
+});
+
+vi.mock("../../src/github/client.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/github/client.js")>();
+  return {
+    ...actual,
+    pingGitHub: mocks.pingGitHub,
+    GitHubClient: vi.fn().mockImplementation(() => ({
+      getBranchRef: vi.fn().mockResolvedValue({ object: { sha: "abc123" } }),
+      getRepository: vi.fn().mockResolvedValue({ permissions: { push: true } }),
+    })),
+  };
+});
+
+vi.mock("@cursor/sdk", () => ({
+  Cursor: {
+    models: { list: vi.fn().mockResolvedValue([{ id: "composer-2.5" }]) },
+    repositories: { list: vi.fn().mockResolvedValue([{ name: "target-app" }]) },
+  },
+}));
+
+import { runDoctor } from "../../src/cli/commands/doctor.js";
+import { EXIT_CONFIG, EXIT_SUCCESS } from "../../src/cli/exit-codes.js";
+
+describe("runDoctor", () => {
+  let tempRoot = "";
+  let configPath = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-doctor-"));
+    configPath = path.join(tempRoot, "harness.config.json");
+    await writeFile(
+      configPath,
+      JSON.stringify({
+        version: 1,
+        orchestratorMarker: "harness-orchestrator-v1",
+        logDirectory: path.join(tempRoot, "runs"),
+        repos: [
+          {
+            id: "target-app",
+            linearProjects: ["Example Target App"],
+            targetRepo: "https://github.com/owner/example-target-app",
+            baseBranch: "main",
+            previewProvider: "vercel",
+            validation: { commands: ["npm run lint"] },
+          },
+        ],
+        allowedTargetRepos: [
+          "https://github.com/owner/example-target-app",
+        ],
+      }),
+      "utf8",
+    );
+
+    process.env.LINEAR_API_KEY = "test-linear";
+    process.env.CURSOR_API_KEY = "test-cursor";
+    mocks.pingLinear.mockResolvedValue("Weston");
+    mocks.pingGitHub.mockResolvedValue("weston-uribe");
+  });
+
+  afterEach(async () => {
+    delete process.env.LINEAR_API_KEY;
+    delete process.env.CURSOR_API_KEY;
+    delete process.env.GITHUB_TOKEN;
+    vi.clearAllMocks();
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("fails when GITHUB_TOKEN is missing", async () => {
+    delete process.env.GITHUB_TOKEN;
+    const code = await runDoctor({ configPath });
+    expect(code).toBe(EXIT_CONFIG);
+  });
+
+  it("passes merge profile without CURSOR_API_KEY", async () => {
+    delete process.env.CURSOR_API_KEY;
+    process.env.GITHUB_TOKEN = "test-github";
+    const code = await runDoctor({ configPath, profile: "merge" });
+    expect(code).toBe(EXIT_SUCCESS);
+  });
+
+  it("passes when required tokens are valid", async () => {
+    process.env.GITHUB_TOKEN = "test-github";
+    const code = await runDoctor({ configPath });
+    expect(code).toBe(EXIT_SUCCESS);
+    expect(mocks.pingGitHub).toHaveBeenCalledWith("test-github");
+  });
+
+  it("fails merge profile when GitHub token lacks PR head-branch write", async () => {
+    const { GitHubClient } = await import("../../src/github/client.js");
+    vi.mocked(GitHubClient).mockImplementationOnce(
+      () =>
+        ({
+          getBranchRef: vi.fn().mockResolvedValue({ object: { sha: "abc123" } }),
+          getRepository: vi.fn().mockResolvedValue({ permissions: { pull: true } }),
+        }) as never,
+    );
+    process.env.GITHUB_TOKEN = "test-github";
+
+    const code = await runDoctor({ configPath, profile: "merge" });
+
+    expect(code).toBe(EXIT_CONFIG);
+  });
+});

package/workspace-snapshot/files/tests/cli/finalize-exit.test.ts

@@ -0,0 +1,28 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { finalizeCliExit } from "../../src/cli/finalize-exit.js";
+
+describe("finalizeCliExit", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("exits with the provided exit code", () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
+      throw new Error("process.exit called");
+    }) as never);
+
+    expect(() => finalizeCliExit(2)).toThrow("process.exit called");
+    expect(exitSpy).toHaveBeenCalledWith(2);
+  });
+
+  it("defaults to exit code 0 when exit code is not a finite number", () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {
+      throw new Error("process.exit called");
+    }) as never);
+
+    for (const code of [undefined, null, "2"] as const) {
+      expect(() => finalizeCliExit(code)).toThrow("process.exit called");
+      expect(exitSpy).toHaveBeenLastCalledWith(0);
+    }
+  });
+});

package/workspace-snapshot/files/tests/cli/operator-init.test.ts

@@ -0,0 +1,146 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { runOperatorInit } from "../../src/cli/commands/operator-init.js";
+import { EXIT_SUCCESS } from "../../src/cli/exit-codes.js";
+import { loadConfig } from "../../src/config/load-config.js";
+
+const ENV_EXAMPLE = `# test example
+HARNESS_CONFIG_PATH=.harness/config.local.json
+LINEAR_API_KEY=
+`;
+
+const CONFIG_EXAMPLE = JSON.stringify(
+  {
+    version: 1,
+    orchestratorMarker: "harness-orchestrator-v1",
+    logDirectory: "runs",
+    repos: [
+      {
+        id: "target-app",
+        linearProjects: ["Example Target App"],
+        targetRepo: "https://github.com/owner/example-target-app",
+        baseBranch: "dev",
+      },
+    ],
+    allowedTargetRepos: ["https://github.com/owner/example-target-app"],
+  },
+  null,
+  2,
+);
+
+describe("runOperatorInit", () => {
+  let tempRoot = "";
+  let originalCwd = "";
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-operator-init-"));
+    await writeFile(path.join(tempRoot, ".env.example"), ENV_EXAMPLE, "utf8");
+    await mkdirHarnessExample(tempRoot);
+    process.chdir(tempRoot);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("creates .env.local when missing", async () => {
+    const exitCode = await runOperatorInit();
+    expect(exitCode).toBe(EXIT_SUCCESS);
+
+    const envLocal = await readFile(path.join(tempRoot, ".env.local"), "utf8");
+    expect(envLocal).toContain("HARNESS_CONFIG_PATH=.harness/config.local.json");
+  });
+
+  it("creates .harness/config.local.json when missing", async () => {
+    const exitCode = await runOperatorInit();
+    expect(exitCode).toBe(EXIT_SUCCESS);
+
+    const configLocal = await readFile(
+      path.join(tempRoot, ".harness", "config.local.json"),
+      "utf8",
+    );
+    expect(configLocal).toContain('"id": "target-app"');
+  });
+
+  it("does not overwrite existing files by default", async () => {
+    await writeFile(path.join(tempRoot, ".env.local"), "SENTINEL_ENV", "utf8");
+    await writeFile(
+      path.join(tempRoot, ".harness", "config.local.json"),
+      "SENTINEL_CONFIG",
+      "utf8",
+    );
+
+    await runOperatorInit();
+
+    expect(await readFile(path.join(tempRoot, ".env.local"), "utf8")).toBe(
+      "SENTINEL_ENV",
+    );
+    expect(
+      await readFile(path.join(tempRoot, ".harness", "config.local.json"), "utf8"),
+    ).toBe("SENTINEL_CONFIG");
+  });
+
+  it("overwrites existing files with --force", async () => {
+    await writeFile(path.join(tempRoot, ".env.local"), "SENTINEL_ENV", "utf8");
+    await writeFile(
+      path.join(tempRoot, ".harness", "config.local.json"),
+      "SENTINEL_CONFIG",
+      "utf8",
+    );
+
+    await runOperatorInit({ force: true });
+
+    const envLocal = await readFile(path.join(tempRoot, ".env.local"), "utf8");
+    expect(envLocal).toContain("HARNESS_CONFIG_PATH=.harness/config.local.json");
+    expect(envLocal).not.toBe("SENTINEL_ENV");
+
+    const configLocal = await readFile(
+      path.join(tempRoot, ".harness", "config.local.json"),
+      "utf8",
+    );
+    expect(configLocal).toContain('"id": "target-app"');
+    expect(configLocal).not.toBe("SENTINEL_CONFIG");
+  });
+
+  it("generated local config parses with loadConfig", async () => {
+    await runOperatorInit();
+
+    const config = await loadConfig(
+      path.join(tempRoot, ".harness", "config.local.json"),
+    );
+    expect(config.repos[0]?.id).toBe("target-app");
+  });
+});
+
+describe("committed operator examples", () => {
+  const repoRoot = path.resolve(import.meta.dirname, "../..");
+
+  it("committed examples contain no operator-specific references", async () => {
+    const envExample = await readFile(
+      path.join(repoRoot, ".env.example"),
+      "utf8",
+    );
+    const configExample = await readFile(
+      path.join(repoRoot, ".harness", "config.example.json"),
+      "utf8",
+    );
+
+    const forbidden = /weston-uribe|weston/i;
+    expect(envExample).not.toMatch(forbidden);
+    expect(configExample).not.toMatch(forbidden);
+  });
+});
+
+async function mkdirHarnessExample(root: string): Promise<void> {
+  const harnessDir = path.join(root, ".harness");
+  await mkdir(harnessDir, { recursive: true });
+  await writeFile(
+    path.join(harnessDir, "config.example.json"),
+    CONFIG_EXAMPLE,
+    "utf8",
+  );
+}

package/workspace-snapshot/files/tests/cli/sync-production-dispatch.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { runSyncProductionCommand } from "../../src/cli/commands/sync-production.js";
+import { EXIT_CONFIG } from "../../src/cli/exit-codes.js";
+import type { HarnessConfig } from "../../src/config/types.js";
+import * as issueQuery from "../../src/linear/issue-query.js";
+import * as linearWriter from "../../src/linear/writer.js";
+
+function privateTargetConfig(): HarnessConfig {
+  return {
+    version: 1,
+    orchestratorMarker: "harness-orchestrator-v1",
+    logDirectory: "runs",
+    linear: { teamKey: "WES" },
+    repos: [
+      {
+        id: "real-target",
+        linearProjects: ["Private Target"],
+        targetRepo: "https://github.com/owner/private-target",
+        baseBranch: "dev",
+        productionBranch: "main",
+        integrationSuccessStatus: "Merged to Dev",
+      },
+    ],
+    allowedTargetRepos: ["https://github.com/owner/private-target"],
+  };
+}
+
+describe("runSyncProductionCommand dispatch validation", () => {
+  afterEach(() => {
+    process.argv = ["node", "harness", "sync-production"];
+    delete process.env.HARNESS_CONFIG_JSON;
+    delete process.env.LINEAR_API_KEY;
+    delete process.env.GITHUB_TOKEN;
+    vi.restoreAllMocks();
+  });
+
+  it("accepts real-target when present in injected config", async () => {
+    process.argv = ["node", "harness", "sync-production"];
+    process.env.HARNESS_CONFIG_JSON = JSON.stringify(privateTargetConfig());
+    process.env.LINEAR_API_KEY = "test-linear";
+    process.env.GITHUB_TOKEN = "test-github";
+
+    vi.spyOn(linearWriter, "createLinearClient").mockReturnValue({
+      teams: vi.fn().mockResolvedValue({ nodes: [{ id: "t1", key: "WES" }] }),
+    } as never);
+    vi.spyOn(issueQuery, "listIssuesByStatus").mockResolvedValue([]);
+
+    const exitCode = await runSyncProductionCommand({
+      configPath: "harness.config.json",
+      repo: "real-target",
+      sourceRepo: "owner/private-target",
+      productionBranch: "main",
+      ref: "refs/heads/main",
+      json: true,
+    });
+
+    expect(exitCode).toBe(0);
+  });
+
+  it("rejects real-target when absent from injected config", async () => {
+    process.argv = ["node", "harness", "sync-production"];
+    process.env.HARNESS_CONFIG_JSON = JSON.stringify({
+      version: 1,
+      orchestratorMarker: "harness-orchestrator-v1",
+      logDirectory: "runs",
+      repos: [
+        {
+          id: "target-app",
+          targetRepo: "https://github.com/owner/example-target-app",
+          baseBranch: "main",
+          productionBranch: "main",
+        },
+      ],
+      allowedTargetRepos: ["https://github.com/owner/example-target-app"],
+    });
+    process.env.LINEAR_API_KEY = "test-linear";
+    process.env.GITHUB_TOKEN = "test-github";
+
+    const exitCode = await runSyncProductionCommand({
+      configPath: "harness.config.json",
+      repo: "real-target",
+      json: true,
+    });
+
+    expect(exitCode).toBe(EXIT_CONFIG);
+  });
+
+  it("rejects sourceRepo mismatch", async () => {
+    process.argv = ["node", "harness", "sync-production"];
+    process.env.HARNESS_CONFIG_JSON = JSON.stringify(privateTargetConfig());
+    process.env.LINEAR_API_KEY = "test-linear";
+    process.env.GITHUB_TOKEN = "test-github";
+
+    const exitCode = await runSyncProductionCommand({
+      configPath: "harness.config.json",
+      repo: "real-target",
+      sourceRepo: "owner/wrong-target",
+      json: true,
+    });
+
+    expect(exitCode).toBe(EXIT_CONFIG);
+  });
+});

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

@@ -0,0 +1,99 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { runValidateIssue } from "../../src/cli/commands/validate-issue.js";
+import { EXIT_CONFIG, EXIT_RUN_FAILURE, EXIT_SUCCESS } from "../../src/cli/exit-codes.js";
+
+const repoRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../..",
+);
+
+describe("runValidateIssue", () => {
+  let tempRoot = "";
+  let configPath = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-validate-cli-"));
+    const config = JSON.parse(
+      await import("node:fs/promises").then((fs) =>
+        fs.readFile(path.join(repoRoot, "harness.config.json"), "utf8"),
+      ),
+    );
+    config.logDirectory = path.join(tempRoot, "runs");
+    configPath = path.join(tempRoot, "harness.config.json");
+    await writeFile(configPath, JSON.stringify(config), "utf8");
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("exits 0 for valid-minimal without intended phase", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/valid-minimal.md"),
+    });
+    expect(exitCode).toBe(EXIT_SUCCESS);
+  });
+
+  it("exits 2 for invalid-missing-task without intended phase", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/invalid-missing-task.md"),
+    });
+    expect(exitCode).toBe(EXIT_RUN_FAILURE);
+  });
+
+  it("exits 0 for valid-minimal with intended-phase planning", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/valid-minimal.md"),
+      intendedPhase: "planning",
+    });
+    expect(exitCode).toBe(EXIT_SUCCESS);
+  });
+
+  it("exits 2 for invalid-missing-task with intended-phase planning", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/invalid-missing-task.md"),
+      intendedPhase: "planning",
+    });
+    expect(exitCode).toBe(EXIT_RUN_FAILURE);
+  });
+
+  it("exits 0 for valid-minimal with intended-phase implementation", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/valid-minimal.md"),
+      intendedPhase: "implementation",
+    });
+    expect(exitCode).toBe(EXIT_SUCCESS);
+  });
+
+  it("exits 2 for broad issue with intended-phase implementation", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/broad-for-direct-impl.md"),
+      intendedPhase: "implementation",
+    });
+    expect(exitCode).toBe(EXIT_RUN_FAILURE);
+  });
+
+  it("exits 1 for invalid intended phase", async () => {
+    const exitCode = await runValidateIssue({
+      configPath,
+      filePath: path.join(repoRoot, "tests/fixtures/issues/valid-minimal.md"),
+      intendedPhase: "foo",
+    });
+    expect(exitCode).toBe(EXIT_CONFIG);
+  });
+
+  it("exits 1 when neither file nor issue is provided", async () => {
+    const exitCode = await runValidateIssue({ configPath });
+    expect(exitCode).toBe(EXIT_CONFIG);
+  });
+});

package/workspace-snapshot/files/tests/config/load-dotenv.test.ts

@@ -0,0 +1,64 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadHarnessDotenv } from "../../src/config/load-dotenv.js";
+
+describe("loadHarnessDotenv", () => {
+  let tempRoot = "";
+  const envKeys = ["HARNESS_TEST_FROM_ENV", "HARNESS_TEST_FROM_LOCAL"];
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "harness-load-dotenv-"));
+    for (const key of envKeys) {
+      delete process.env[key];
+    }
+  });
+
+  afterEach(async () => {
+    for (const key of envKeys) {
+      delete process.env[key];
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("loads .env.local and overrides .env values", async () => {
+    await writeFile(
+      path.join(tempRoot, ".env"),
+      "HARNESS_TEST_FROM_ENV=from-env\nHARNESS_TEST_FROM_LOCAL=from-env\n",
+      "utf8",
+    );
+    await writeFile(
+      path.join(tempRoot, ".env.local"),
+      "HARNESS_TEST_FROM_LOCAL=from-local\n",
+      "utf8",
+    );
+
+    loadHarnessDotenv(tempRoot);
+
+    expect(process.env.HARNESS_TEST_FROM_ENV).toBe("from-env");
+    expect(process.env.HARNESS_TEST_FROM_LOCAL).toBe("from-local");
+  });
+
+  it("does not fail when .env.local is missing", async () => {
+    await writeFile(
+      path.join(tempRoot, ".env"),
+      "HARNESS_TEST_FROM_ENV=from-env\n",
+      "utf8",
+    );
+
+    expect(() => loadHarnessDotenv(tempRoot)).not.toThrow();
+    expect(process.env.HARNESS_TEST_FROM_ENV).toBe("from-env");
+  });
+
+  it("does not fail when .env is missing", async () => {
+    await writeFile(
+      path.join(tempRoot, ".env.local"),
+      "HARNESS_TEST_FROM_LOCAL=from-local\n",
+      "utf8",
+    );
+
+    expect(() => loadHarnessDotenv(tempRoot)).not.toThrow();
+    expect(process.env.HARNESS_TEST_FROM_LOCAL).toBe("from-local");
+  });
+});