@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

package/src/resources/extensions/gsd/tests/provider-payload-policy.test.ts

@@ -0,0 +1,165 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ContextManagementConfig } from "../preferences-types.js";
+import type { ProviderPayloadPolicyDeps } from "../provider-payload-policy.js";
+
+import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
+
+function createDeps(
+  overrides: Partial<ProviderPayloadPolicyDeps> & {
+    context?: ContextManagementConfig | undefined;
+    autoActive?: boolean;
+    sourceContextBlock?: string | null;
+  } = {},
+): ProviderPayloadPolicyDeps {
+  return {
+    isAutoActive: () => overrides.autoActive ?? false,
+    loadContextManagementConfig: () => overrides.context,
+    renderSourceContextBlock: () => overrides.sourceContextBlock ?? null,
+    getEffectiveServiceTier: () => undefined,
+    supportsServiceTier: () => false,
+    ...overrides,
+  };
+}
+
+function textFromMessage(message: { content?: unknown }): string {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const text = content.find((block): block is { text: string } => {
+    return Boolean(block && typeof block === "object" && "text" in block && typeof block.text === "string");
+  });
+  return text?.text ?? "";
+}
+
+test("provider payload policy truncates tool results outside auto-mode without masking", () => {
+  const messageText = "m".repeat(50);
+  const responsesOutput = "r".repeat(50);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "toolResult", content: [{ type: "text", text: messageText }] },
+    ],
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "keep me" }] },
+      { type: "function_call_output", call_id: "call_test", output: responsesOutput },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({ context: { observation_mask_turns: 1, tool_result_max_chars: 10 } }),
+  });
+
+  const truncatedMessage = textFromMessage(payload.messages[1]);
+  const truncatedResponsesOutput = String(payload.input[1]?.output ?? "");
+  assert.match(truncatedMessage, /\[truncated\]/);
+  assert.match(truncatedResponsesOutput, /\[truncated\]/);
+  assert.doesNotMatch(truncatedMessage, /result masked/);
+  assert.doesNotMatch(truncatedResponsesOutput, /result masked/);
+});
+
+test("provider payload policy appends source context after masking and truncation", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "full source text ".repeat(20);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "old turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "old result ".repeat(20) }] },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      { role: "user", content: [{ type: "text", text: "new turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "new result ".repeat(20) }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  const oldResult = textFromMessage(payload.messages[1]);
+  const newResult = textFromMessage(payload.messages[4]);
+  const appendedContext = textFromMessage(payload.messages[payload.messages.length - 1]);
+
+  assert.match(oldResult, /result masked/);
+  assert.match(newResult, /\[truncated\]/);
+  assert.equal(appendedContext, sourceContextBlock);
+  assert.doesNotMatch(appendedContext, /\[truncated\]/);
+});
+
+test("provider payload policy applies ordering to Responses input payloads", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "responses source text ".repeat(20);
+  const payload = {
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "old turn" }] },
+      { type: "function_call_output", call_id: "call_old", output: "old result ".repeat(20) },
+      { type: "message", role: "assistant", content: [{ type: "output_text", text: "ok" }] },
+      { role: "user", content: [{ type: "input_text", text: "new turn" }] },
+      { type: "function_call_output", call_id: "call_new", output: "new result ".repeat(20) },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  assert.match(String(payload.input[1]?.output ?? ""), /result masked/);
+  assert.match(String(payload.input[4]?.output ?? ""), /\[truncated\]/);
+  assert.equal(textFromMessage(payload.input[payload.input.length - 1]), sourceContextBlock);
+});
+
+test("provider payload policy replaces existing source context blocks", () => {
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "user", content: [{ type: "text", text: "## Source Context Block\n\nstale" }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      sourceContextBlock: "## Source Context Block\n\nfresh",
+    }),
+  });
+
+  const sourceMessages = payload.messages.filter((message) => {
+    return textFromMessage(message).startsWith("## Source Context Block");
+  });
+  assert.equal(sourceMessages.length, 1);
+  assert.equal(textFromMessage(sourceMessages[0]), "## Source Context Block\n\nfresh");
+});
+
+test("provider payload policy sets service tier only for supported models", () => {
+  const unsupported = {};
+  applyProviderPayloadPolicy({
+    payload: unsupported,
+    modelId: "claude-opus-4-6",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal("service_tier" in unsupported, false);
+
+  const supported: Record<string, unknown> = {};
+  applyProviderPayloadPolicy({
+    payload: supported,
+    modelId: "gpt-5.4",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal(supported.service_tier, "priority");
+});

package/src/resources/extensions/gsd/tests/publication.test.ts

@@ -0,0 +1,120 @@
+// gsd-pi — ADR-034 Publication module tests.
+//
+// Exercises publishMilestone against real local git fixtures (a bare repo as
+// the remote) — no network, no gh. The PR path is only tested up to its
+// non-fatal failure contract, since createDraftPullRequestFromEvidence shells
+// out to gh.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { gitRemoteExists, publishMilestone } from "../publication.ts";
+import { git, makeTempDir, makeTempRepo } from "./test-utils.ts";
+
+function makeRepoWithBareRemote(): { repo: string; bare: string; cleanup: () => void } {
+  const repo = makeTempRepo("gsd-publication-test-");
+  const bare = join(makeTempDir("gsd-publication-remote-"), "remote.git");
+  git(repo, "init", "--bare", bare);
+  git(repo, "remote", "add", "origin", bare);
+  return {
+    repo,
+    bare,
+    cleanup: () => {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(bare, { recursive: true, force: true });
+    },
+  };
+}
+
+const NO_PUBLISH_PREFS = { autoPush: false, autoPr: false };
+
+function makeRequest(repo: string, prefs: { autoPush: boolean; autoPr: boolean; remote?: string; prTargetBranch?: string }) {
+  return {
+    basePath: repo,
+    milestoneId: "M001",
+    milestoneTitle: "Test milestone",
+    integrationBranch: "main",
+    milestoneBranch: "milestone/M001",
+    sliceSummaries: ["### S01\nSlice one"],
+    nothingToCommit: false,
+    prefs,
+  };
+}
+
+test("gitRemoteExists distinguishes configured from missing remotes", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    assert.equal(gitRemoteExists(repo, "origin"), true);
+    assert.equal(gitRemoteExists(repo, "upstream"), false);
+  } finally {
+    cleanup();
+  }
+});
+
+test("auto-push pushes the integration branch to the remote", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: false }));
+    assert.equal(result.pushed, true);
+    assert.equal(result.prCreated, false);
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.match(remoteHeads, /refs\/heads\/main/);
+  } finally {
+    cleanup();
+  }
+});
+
+test("auto-push is suppressed when auto-PR owns the remote interaction", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    git(repo, "branch", "milestone/M001");
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: true }));
+    // PR creation pushes the milestone branch, then fails non-fatally at gh.
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(result.prUrl, undefined);
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.match(remoteHeads, /refs\/heads\/milestone\/M001/);
+    assert.doesNotMatch(remoteHeads, /refs\/heads\/main/);
+  } finally {
+    cleanup();
+  }
+});
+
+test("nothing-to-commit short-circuits all publication", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone({
+      ...makeRequest(repo, { autoPush: true, autoPr: false }),
+      nothingToCommit: true,
+    });
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.equal(remoteHeads.trim(), "");
+  } finally {
+    cleanup();
+  }
+});
+
+test("missing remote makes publication a silent no-op", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    git(repo, "remote", "remove", "origin");
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: true }));
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+  } finally {
+    cleanup();
+  }
+});
+
+test("publication disabled returns the empty result without touching git", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone(makeRequest(repo, NO_PUBLISH_PREFS));
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+  } finally {
+    cleanup();
+  }
+});

package/src/resources/extensions/gsd/tests/pull-request-process.test.ts

@@ -0,0 +1,47 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for process-level pull request policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildPullRequestEvidence,
+  createDraftPullRequestFromEvidence,
+} from "../pull-request-process.js";
+
+test("buildPullRequestEvidence omits AI credit by policy", () => {
+  const evidence = buildPullRequestEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Git process",
+    aiAssisted: true,
+  });
+
+  assert.equal(evidence.title, "feat: Git process");
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+  assert.ok(!evidence.body.includes("AI assistance"));
+});
+
+test("createDraftPullRequestFromEvidence forwards exact evidence and branch options", () => {
+  const calls: unknown[][] = [];
+  const url = createDraftPullRequestFromEvidence(
+    "/repo",
+    "M001",
+    { title: "feat: Git process", body: "body" },
+    { head: "milestone/M001", base: "main" },
+    {
+      createDraftPR: (basePath, milestoneId, title, body, opts) => {
+        calls.push([basePath, milestoneId, title, body, opts]);
+        return "https://github.example/pr/1";
+      },
+    },
+  );
+
+  assert.equal(url, "https://github.example/pr/1");
+  assert.deepEqual(calls, [[
+    "/repo",
+    "M001",
+    "feat: Git process",
+    "body",
+    { head: "milestone/M001", base: "main" },
+  ]]);
+});

package/src/resources/extensions/gsd/tests/recovery-classification-illegal-transition.test.ts

@@ -0,0 +1,30 @@
+// GSD — recovery-classification: illegal-transition kind (ADR-030)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyFailure } from "../recovery-classification.ts";
+import { IllegalPhaseTransitionError } from "../state-transition-matrix.ts";
+
+test("classifyFailure recognizes IllegalPhaseTransitionError by class and escalates", () => {
+  const classification = classifyFailure({
+    error: new IllegalPhaseTransitionError("executing", "complete"),
+    unitType: "execute-task",
+    unitId: "T-1",
+  });
+
+  assert.equal(classification.failureKind, "illegal-transition");
+  assert.equal(classification.action, "escalate");
+  assert.equal(classification.exitReason, "illegal-transition");
+  assert.match(classification.reason, /Illegal phase transition/);
+});
+
+test("classifyFailure routes an explicit illegal-transition failureKind to the same case", () => {
+  const classification = classifyFailure({
+    error: new Error("derived edge rejected"),
+    failureKind: "illegal-transition",
+  });
+
+  assert.equal(classification.failureKind, "illegal-transition");
+  assert.equal(classification.action, "escalate");
+});