@guilz-dev/sdlc-gh 0.1.0

package/scripts/test-issue-spec-scenarios.mjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * Scenario tests for CC-SD issue-spec-check validation.
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import {
+  CCSD_ENFORCED_TASK_CLASSES,
+  isPlaceholderContent,
+  pickLinkedIssue,
+  resolveFetchFailureAction,
+  shouldEnforceCcsd,
+  validateCcsdFields,
+  validateLabelShape,
+} from "./lib/ccsd-contract.mjs";
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const CHECK_SCRIPT = join(ROOT, "check-issue-spec.mjs");
+
+function completeIssueBody({ omitField } = {}) {
+  const fields = {
+    Goal: "Update the README quick-start section with bootstrap instructions.",
+    "Non-goals": "- Do not change CI workflows\n- Do not modify sample code",
+    Constraints: "- Markdown only\n- Keep under 60 LOC",
+    "Acceptance criteria":
+      "- [ ] README lists all three bootstrap options\n- [ ] Links resolve correctly",
+    "Rollback hints": "Revert the single README commit.",
+  };
+  if (omitField) delete fields[omitField];
+  return Object.entries(fields)
+    .map(([k, v]) => `### ${k}\n\n${v}`)
+    .join("\n\n");
+}
+
+function runCheck(env) {
+  return spawnSync("node", [CHECK_SCRIPT], {
+    env: { ...process.env, ...env },
+    encoding: "utf8",
+  });
+}
+
+function assertExit(name, result, expectedCode) {
+  if (result.status !== expectedCode) {
+    console.error(`::error::${name}: expected exit ${expectedCode}, got ${result.status}`);
+    console.error(result.stdout);
+    console.error(result.stderr);
+    process.exit(1);
+  }
+}
+
+// Unit-level checks
+const complete = validateCcsdFields(completeIssueBody());
+if (!complete.ok) {
+  console.error("::error::Complete issue body should pass validation");
+  process.exit(1);
+}
+
+const missingNonGoals = validateCcsdFields(completeIssueBody({ omitField: "Non-goals" }));
+if (missingNonGoals.ok || !missingNonGoals.missing.includes("Non-goals")) {
+  console.error("::error::Missing Non-goals should fail validation");
+  process.exit(1);
+}
+
+const placeholderRollback = validateCcsdFields(
+  completeIssueBody().replace(
+    "Revert the single README commit.",
+    "How to revert this change immediately if needed.",
+  ),
+);
+if (placeholderRollback.ok || !placeholderRollback.placeholder.includes("Rollback hints")) {
+  console.error("::error::Placeholder Rollback hints should fail validation");
+  process.exit(1);
+}
+
+const goalWithExtra = isPlaceholderContent(
+  "One short paragraph describing what this task achieves. Update the README quick-start.",
+);
+if (goalWithExtra) {
+  console.error("::error::Goal with placeholder prefix plus real content should pass");
+  process.exit(1);
+}
+
+const nonGoalsWithReal = validateCcsdFields(
+  completeIssueBody().replace(
+    "- Do not change CI workflows\n- Do not modify sample code",
+    "- Item the task must not do or change\n- Do not change CI workflows",
+  ),
+);
+if (!nonGoalsWithReal.ok) {
+  console.error("::error::Non-goals with placeholder line plus real bullets should pass");
+  process.exit(1);
+}
+
+const acceptancePlaceholderOnly = validateCcsdFields(
+  completeIssueBody().replace(
+    "- [ ] README lists all three bootstrap options\n- [ ] Links resolve correctly",
+    "- [ ] Criterion 1\n- [ ] Criterion 2",
+  ),
+);
+if (acceptancePlaceholderOnly.ok || !acceptancePlaceholderOnly.placeholder.includes("Acceptance criteria")) {
+  console.error("::error::Placeholder-only Acceptance criteria should fail validation");
+  process.exit(1);
+}
+
+const acceptanceWithReal = validateCcsdFields(
+  completeIssueBody().replace(
+    "- [ ] README lists all three bootstrap options\n- [ ] Links resolve correctly",
+    "- [ ] Criterion 1\n- [ ] README lists all three bootstrap options",
+  ),
+);
+if (!acceptanceWithReal.ok) {
+  console.error("::error::Acceptance criteria with placeholder line plus real item should pass");
+  process.exit(1);
+}
+
+const ambiguous = pickLinkedIssue([
+  { body: "a", labels: ["task:docs", "autonomy:L1"], issueNumber: 1 },
+  { body: "b", labels: ["task:test-fix", "autonomy:L1"], issueNumber: 2 },
+]);
+if (ambiguous.kind !== "ambiguous") {
+  console.error("::error::Multiple enforced issues should be flagged as ambiguous");
+  process.exit(1);
+}
+
+const preferEnforced = pickLinkedIssue([
+  { body: "skip", labels: ["task:feature-small", "autonomy:L1"], issueNumber: 10 },
+  { body: "enforce", labels: ["task:docs", "autonomy:L1"], issueNumber: 11 },
+]);
+if (preferEnforced.kind !== "issue" || preferEnforced.issueNumber !== 11) {
+  console.error("::error::pickLinkedIssue should prefer the enforced L1 docs/test-fix issue");
+  process.exit(1);
+}
+
+if (!shouldEnforceCcsd(["task:docs", "autonomy:L1"])) {
+  console.error("::error::task:docs + autonomy:L1 should trigger enforcement");
+  process.exit(1);
+}
+
+if (shouldEnforceCcsd(["task:feature-small", "autonomy:L1"])) {
+  console.error("::error::task:feature-small should not trigger enforcement in v1");
+  process.exit(1);
+}
+
+for (const taskClass of ["infra", "security-sensitive"]) {
+  if (shouldEnforceCcsd([`task:${taskClass}`, "autonomy:L1"])) {
+    console.error(`::error::task:${taskClass} should not trigger enforcement`);
+    process.exit(1);
+  }
+}
+
+if (CCSD_ENFORCED_TASK_CLASSES.length !== 2) {
+  console.error("::error::v1 should enforce exactly docs and test-fix");
+  process.exit(1);
+}
+
+// Integration checks via check-issue-spec.mjs
+const l1Labels = "task:docs,autonomy:L1";
+
+assertExit(
+  "docs+L1 complete passes",
+  runCheck({ ISSUE_BODY: completeIssueBody(), ISSUE_LABELS: l1Labels }),
+  0,
+);
+
+assertExit(
+  "docs+L1 missing Non-goals fails",
+  runCheck({
+    ISSUE_BODY: completeIssueBody({ omitField: "Non-goals" }),
+    ISSUE_LABELS: l1Labels,
+  }),
+  1,
+);
+
+assertExit(
+  "docs+L1 placeholder Rollback hints fails",
+  runCheck({
+    ISSUE_BODY: completeIssueBody().replace(
+      "Revert the single README commit.",
+      "How to revert this change immediately if needed.",
+    ),
+    ISSUE_LABELS: l1Labels,
+  }),
+  1,
+);
+
+assertExit(
+  "test-fix+L1 complete passes",
+  runCheck({
+    ISSUE_BODY: completeIssueBody().replace("README", "flaky unit test"),
+    ISSUE_LABELS: "task:test-fix,autonomy:L1",
+  }),
+  0,
+);
+
+assertExit(
+  "feature-small+L1 skips (passes)",
+  runCheck({
+    ISSUE_BODY: completeIssueBody({ omitField: "Non-goals" }),
+    ISSUE_LABELS: "task:feature-small,autonomy:L1",
+  }),
+  0,
+);
+
+assertExit(
+  "docs+L1 without linked issue fails when inferred from PR labels",
+  runCheck({
+    PR_LABELS: "task:docs,autonomy:L1",
+  }),
+  1,
+);
+
+for (const taskClass of ["infra", "security-sensitive"]) {
+  assertExit(
+    `${taskClass}+L1 skips (passes)`,
+    runCheck({
+      ISSUE_BODY: completeIssueBody({ omitField: "Non-goals" }),
+      ISSUE_LABELS: `task:${taskClass},autonomy:L1`,
+    }),
+    0,
+  );
+}
+
+const multipleTaskLabels = validateLabelShape([
+  "task:docs",
+  "task:test-fix",
+  "autonomy:L1",
+]);
+if (multipleTaskLabels.ok) {
+  console.error("::error::Multiple task:* labels should fail label shape validation");
+  process.exit(1);
+}
+
+assertExit(
+  "multiple task labels on L1 docs fails",
+  runCheck({
+    ISSUE_BODY: completeIssueBody(),
+    ISSUE_LABELS: "task:docs,task:test-fix,autonomy:L1",
+  }),
+  1,
+);
+
+if (resolveFetchFailureAction(["task:docs", "autonomy:L1"]) !== "fail") {
+  console.error("::error::Fetch failure with L1 docs proxy labels should fail");
+  process.exit(1);
+}
+
+if (resolveFetchFailureAction(["task:infra", "autonomy:L1"]) !== "warn_skip") {
+  console.error("::error::Fetch failure with infra proxy labels should warn/skip");
+  process.exit(1);
+}
+
+if (resolveFetchFailureAction([]) !== "warn_skip") {
+  console.error("::error::Fetch failure without proxy labels should warn/skip");
+  process.exit(1);
+}
+
+console.log("Issue-spec scenario tests passed");

package/scripts/test-l1-readiness-scenarios.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { runReadinessCheck } from "./lib/l1-readiness.mjs";
+
+const ROOT = resolve(process.cwd());
+const checker = join(ROOT, "scripts/check-l1-readiness.mjs");
+
+function writeMinimalHarness(repoDir, { stack = "ts", includeAgents = true, templateCodeowners = true } = {}) {
+  mkdirSync(join(repoDir, ".github/workflows"), { recursive: true });
+  mkdirSync(join(repoDir, ".github/ISSUE_TEMPLATE"), { recursive: true });
+  if (includeAgents) {
+    mkdirSync(join(repoDir, ".github/agents"), { recursive: true });
+  }
+  writeFileSync(
+    join(repoDir, ".github/CODEOWNERS"),
+    templateCodeowners
+      ? "# template\n/.github/ @your-org/harness-engineers\n"
+      : "* @acme/platform\n",
+  );
+  writeFileSync(join(repoDir, ".github/workflows/harness-ci.yml"), "name: harness-ci\n");
+  writeFileSync(join(repoDir, `.github/workflows/product-ci-${stack}.yml`), `name: product-ci-${stack}\n`);
+  writeFileSync(join(repoDir, ".github/workflows/copilot-setup-steps.yml"), "name: Copilot setup\n");
+  writeFileSync(join(repoDir, ".github/ISSUE_TEMPLATE/task.yml"), "name: Task\n");
+  if (includeAgents) {
+    writeFileSync(join(repoDir, ".github/agents/triager.agent.md"), "---\nname: triager\n---\n");
+    writeFileSync(join(repoDir, ".github/agents/implementer.agent.md"), "---\nname: implementer\n---\n");
+  }
+}
+
+function makeFakeGh(binDir, handlers) {
+  const fakeGh = join(binDir, "gh");
+  const handlerSource = handlers
+    .map(
+      (handler, index) => `
+function handler${index}(args) {
+  ${handler.body}
+}
+`,
+    )
+    .join("\n");
+  const dispatch = handlers
+    .map((handler, index) => `if (${handler.match}) return handler${index}(args);`)
+    .join("\n");
+
+  writeFileSync(
+    fakeGh,
+    `#!/usr/bin/env node
+const args = process.argv.slice(2);
+${handlerSource}
+${dispatch}
+process.stderr.write("unexpected gh invocation: " + JSON.stringify(args) + "\\n");
+process.exit(1);
+`,
+    { mode: 0o755 },
+  );
+}
+
+const repoDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-"));
+writeMinimalHarness(repoDir);
+
+const noGhBinDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-no-gh-bin-"));
+makeFakeGh(noGhBinDir, [
+  {
+    match: 'args[0] === "--version"',
+    body: 'process.stdout.write("gh version 2.0.0\\n"); process.exit(0);',
+  },
+  {
+    match: 'args[0] === "auth" && args[1] === "status"',
+    body: "process.exit(1);",
+  },
+]);
+const isolatedEnv = {
+  ...process.env,
+  PATH: `${noGhBinDir}:${process.env.PATH}`,
+};
+
+const normal = spawnSync("node", [checker, "--template"], {
+  cwd: repoDir,
+  encoding: "utf8",
+  env: isolatedEnv,
+});
+assert.equal(normal.status, 0, normal.stderr);
+assert.match(normal.stdout, /PASS doctor:CODEOWNERS: template placeholder preserved/);
+assert.match(normal.stdout, /MANUAL Copilot coding agent entitlement/);
+assert.match(normal.stdout, /SKIP GitHub CLI\/Auth/);
+
+const strict = spawnSync("node", [checker, "--template", "--strict"], {
+  cwd: repoDir,
+  encoding: "utf8",
+  env: isolatedEnv,
+});
+assert.equal(strict.status, 1, `expected strict mode to fail on SKIP entries\n${strict.stdout}\n${strict.stderr}`);
+assert.match(strict.stdout, /SKIP GitHub CLI\/Auth/);
+
+const json = spawnSync("node", [checker, "--template", "--json"], {
+  cwd: repoDir,
+  encoding: "utf8",
+  env: isolatedEnv,
+});
+assert.equal(json.status, 0, json.stderr);
+const parsed = JSON.parse(json.stdout);
+assert.equal(parsed.profile, "template");
+assert.equal(parsed.stackId, "ts");
+assert.equal(Array.isArray(parsed.entries), true);
+assert.equal(parsed.exitCode, 0);
+
+const missingAgentsDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-missing-"));
+writeMinimalHarness(missingAgentsDir, { includeAgents: false });
+const missing = runReadinessCheck({
+  template: true,
+  strict: false,
+  repoRoot: missingAgentsDir,
+});
+assert.equal(missing.exitCode, 1, "missing L1 assets should fail");
+assert.ok(
+  missing.entries.some((entry) => entry.label.includes("implementer.agent.md") && entry.status === "FAIL"),
+  "expected missing implementer agent to fail",
+);
+
+const inferredDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-inferred-"));
+writeMinimalHarness(inferredDir, { stack: "python", templateCodeowners: false });
+const inferredReport = runReadinessCheck({
+  template: false,
+  strict: false,
+  repoRoot: inferredDir,
+});
+assert.equal(inferredReport.stackId, "python");
+assert.ok(
+  inferredReport.entries.some(
+    (entry) => entry.label === "doctor:.harness-stack" && entry.status === "PASS" && entry.detail.includes("inferred python"),
+  ),
+);
+
+const ghBinDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-gh-bin-"));
+makeFakeGh(ghBinDir, [
+  {
+    match: 'args[0] === "--version"',
+    body: 'process.stdout.write("gh version 2.0.0\\n"); process.exit(0);',
+  },
+  {
+    match: 'args[0] === "auth" && args[1] === "status"',
+    body: "process.exit(0);",
+  },
+  {
+    match: 'args[0] === "repo" && args[1] === "view"',
+    body: 'process.stdout.write(JSON.stringify({ nameWithOwner: "acme/product" }) + "\\n"); process.exit(0);',
+  },
+  {
+    match: 'args[0] === "api" && args[1].includes("/labels")',
+    body: 'process.stdout.write(JSON.stringify([{ name: "task:docs" }, { name: "task:test-fix" }, { name: "autonomy:L1" }]) + "\\n"); process.exit(0);',
+  },
+  {
+    match: 'args[0] === "api" && args[1].endsWith("/rulesets")',
+    body: 'process.stdout.write(JSON.stringify([{ id: 1, name: "main-protection" }]) + "\\n"); process.exit(0);',
+  },
+  {
+    match: 'args[0] === "api" && args[1].includes("/rulesets/1")',
+    body: `process.stdout.write(JSON.stringify({
+      enforcement: "active",
+      rules: [{
+        type: "required_status_checks",
+        parameters: {
+          required_status_checks: [
+            { context: "harness-static" },
+            { context: "diff-size" },
+            { context: "issue-spec-check" },
+            { context: "product-ci-python" },
+          ],
+        },
+      }],
+    }) + "\\n"); process.exit(0);`,
+  },
+  {
+    match: 'args[0] === "api" && args[1].includes("copilot-setup-steps.yml/runs")',
+    body: `process.stdout.write(JSON.stringify({
+      workflow_runs: [{ id: 99, status: "in_progress", conclusion: null }],
+    }) + "\\n"); process.exit(0);`,
+  },
+]);
+
+const ghRepoDir = mkdtempSync(join(tmpdir(), "sdlc-gh-l1-readiness-gh-"));
+writeMinimalHarness(ghRepoDir, { stack: "python", templateCodeowners: false });
+const ghReport = spawnSync("node", [checker, "--github-repo", "acme/product", "--json"], {
+  cwd: ghRepoDir,
+  encoding: "utf8",
+  env: {
+    ...process.env,
+    PATH: `${ghBinDir}:${process.env.PATH}`,
+  },
+});
+assert.equal(ghReport.status, 0, ghReport.stderr);
+const ghParsed = JSON.parse(ghReport.stdout);
+assert.ok(
+  ghParsed.entries.some(
+    (entry) => entry.label === "Copilot setup workflow" && entry.status === "WARN" && entry.detail.includes("in_progress"),
+  ),
+  "in-progress copilot setup should warn, not fail",
+);
+
+console.log("L1 readiness scenario tests passed");

package/scripts/test-merge-harness-package-scenarios.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { mergeHarnessPackageJson } from "./lib/merge-harness-package.mjs";
+
+const ROOT = resolve(process.cwd());
+const templatePath = join(ROOT, "package.json");
+
+const mergeDir = mkdtempSync(join(tmpdir(), "sdlc-gh-merge-pkg-"));
+const targetPath = join(mergeDir, "package.json");
+writeFileSync(
+  targetPath,
+  `${JSON.stringify(
+    {
+      name: "my-product",
+      version: "1.0.0",
+      private: true,
+      scripts: {
+        test: "vitest run",
+        build: "tsc -p tsconfig.json",
+      },
+      dependencies: {
+        react: "^19.0.0",
+      },
+    },
+    null,
+    2,
+  )}\n`,
+);
+
+const merged = mergeHarnessPackageJson(templatePath, targetPath);
+assert.equal(merged.action, "merged");
+const parsed = JSON.parse(readFileSync(targetPath, "utf8"));
+assert.equal(parsed.name, "my-product");
+assert.equal(parsed.version, "1.0.0");
+assert.deepEqual(parsed.dependencies, { react: "^19.0.0" });
+assert.equal(parsed.scripts.test, "vitest run");
+assert.equal(parsed.scripts.build, "tsc -p tsconfig.json");
+assert.equal(typeof parsed.scripts["check-l1-readiness"], "string");
+assert.equal(typeof parsed.scripts.validate, "string");
+
+const createDir = mkdtempSync(join(tmpdir(), "sdlc-gh-merge-pkg-create-"));
+const createdPath = join(createDir, "package.json");
+const created = mergeHarnessPackageJson(templatePath, createdPath);
+assert.equal(created.action, "created");
+const createdParsed = JSON.parse(readFileSync(createdPath, "utf8"));
+assert.equal(createdParsed.private, true);
+assert.equal(typeof createdParsed.scripts["check-l1-readiness"], "string");
+assert.equal(createdParsed.name, undefined);
+
+console.log("Merge harness package scenario tests passed");

package/scripts/test-npm-package-scenarios.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import {
+  NPM_PACKAGE_FILES,
+  isPathCoveredByNpmFiles,
+  postInstallHint,
+  validateNpmSampleCoverage,
+  validatePackageJsonFiles,
+} from "./lib/npm-package.mjs";
+
+const ROOT = resolve(process.cwd());
+
+assert.equal(isPathCoveredByNpmFiles("sample/ts/src/index.ts"), true);
+assert.equal(isPathCoveredByNpmFiles("sample/ts/node_modules/foo.js"), false);
+assert.equal(isPathCoveredByNpmFiles("sample/php/vendor/autoload.php"), false);
+
+const pkgCheck = validatePackageJsonFiles(ROOT);
+assert.equal(pkgCheck.ok, true, pkgCheck.reason);
+
+const coverage = validateNpmSampleCoverage(ROOT);
+assert.deepEqual(coverage.missingOnDisk, []);
+assert.deepEqual(coverage.notPacked, []);
+
+assert.match(postInstallHint("ts"), /npm install/);
+assert.match(postInstallHint("php"), /composer install/);
+
+assert.ok(NPM_PACKAGE_FILES.includes("sample/go"));
+assert.ok(NPM_PACKAGE_FILES.includes("scripts"));
+
+console.log("npm package scenario tests passed");

package/scripts/test-sdlc-gh-cli-scenarios.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { isTemplateRoot, resolveTemplateRoot } from "./lib/template-root.mjs";
+import { runBootstrap } from "./lib/setup-wizard.mjs";
+
+const ROOT = resolve(process.cwd());
+assert.equal(isTemplateRoot(ROOT), true);
+
+const resolved = resolveTemplateRoot({ fromModule: import.meta.url });
+assert.equal(resolved, ROOT);
+
+const emptyDir = mkdtempSync(join(tmpdir(), "sdlc-gh-cli-empty-"));
+const prevCwd = process.cwd();
+try {
+  process.chdir(emptyDir);
+  let threw = false;
+  try {
+    resolveTemplateRoot();
+  } catch (error) {
+    threw = true;
+    assert.match(String(error.message), /Unable to locate harness template root/);
+  }
+  assert.equal(threw, true);
+} finally {
+  process.chdir(prevCwd);
+}
+
+const targetDir = mkdtempSync(join(tmpdir(), "sdlc-gh-cli-target-"));
+mkdirSync(targetDir, { recursive: true });
+const bootstrapResult = runBootstrap({
+  repoRoot: targetDir,
+  stackId: "ts",
+  mode: "new",
+  owner: "@acme/platform",
+  yes: true,
+  templateRoot: ROOT,
+});
+assert.equal(bootstrapResult.status, 0, bootstrapResult.stderr || bootstrapResult.stdout);
+assert.equal(
+  spawnSync("test", ["-f", join(targetDir, ".github/workflows/harness-ci.yml")]).status,
+  0,
+);
+
+const helpResult = spawnSync(process.execPath, [join(ROOT, "scripts/sdlc-gh-cli.mjs"), "--help"], {
+  encoding: "utf8",
+});
+assert.equal(helpResult.status, 0);
+assert.match(helpResult.stdout, /@guilz-dev\/sdlc-gh/);
+
+console.log("sdlc-gh CLI scenario tests passed");