nightralph 0.0.0

package/dist/test/integration.test.js

@@ -0,0 +1,848 @@
+// test/integration.test.ts
+import { test } from "@substrate-system/tapzero";
+import {
+  mkdtempSync,
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync2,
+  existsSync as existsSync3,
+  rmSync
+} from "node:fs";
+import { join as join3 } from "node:path";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+
+// src/resolve.ts
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { select } from "@inquirer/prompts";
+function findFeatureDirs(cwd) {
+  const scratchDir = join(cwd, ".scratch");
+  if (!existsSync(scratchDir)) return [];
+  const entries = readdirSync(
+    scratchDir,
+    { withFileTypes: true }
+  );
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const issuesDir = join(
+      scratchDir,
+      entry.name,
+      "issues"
+    );
+    const specFile = join(
+      scratchDir,
+      entry.name,
+      "spec.md"
+    );
+    if (existsSync(issuesDir)) {
+      results.push({
+        name: entry.name,
+        dir: issuesDir,
+        spec: specFile
+      });
+    }
+  }
+  return results;
+}
+async function resolveIssuesDir(dirFlag, specFlag, cwd = process.cwd()) {
+  if (dirFlag && specFlag) {
+    return { dir: dirFlag, spec: specFlag };
+  }
+  const features = findFeatureDirs(cwd);
+  if (features.length === 0) {
+    console.error(
+      "No .scratch/<feature>/issues/ directories found.\nProvide --dir and --spec explicitly."
+    );
+    process.exit(2);
+  }
+  let chosen;
+  if (features.length === 1) {
+    chosen = features[0];
+    console.log(`Using feature: ${chosen.name}`);
+  } else {
+    const name = await select({
+      message: "Which feature?",
+      choices: features.map((f) => ({
+        name: f.name,
+        value: f.name
+      }))
+    });
+    chosen = features.find((f) => f.name === name);
+  }
+  const dir = dirFlag ?? chosen.dir;
+  const spec = specFlag ?? chosen.spec;
+  return { dir, spec };
+}
+
+// src/setup.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { join as join2 } from "node:path";
+import { execSync } from "node:child_process";
+var SKILL_DIRS = [
+  "grill",
+  "grilling",
+  "domain-modeling",
+  "to-spec",
+  "to-tickets",
+  "tdd"
+];
+var DOC_TEMPLATES = [
+  "triage-labels.md",
+  "domain.md"
+];
+var TRACKER_TEMPLATES = {
+  local: "issue-tracker.md",
+  github: "issue-tracker-github.md"
+};
+function setup(opts) {
+  const {
+    bundledSkillsDir,
+    docsTemplatesDir,
+    projectDir,
+    claude,
+    tracker
+  } = opts;
+  const agentsSkillsDir = join2(
+    projectDir,
+    ".agents",
+    "skills"
+  );
+  const upstream = JSON.parse(
+    readFileSync(
+      join2(bundledSkillsDir, "upstream.json"),
+      "utf8"
+    )
+  );
+  console.log("Installing skills to .agents/skills/\n");
+  for (const skill of SKILL_DIRS) {
+    const src = join2(bundledSkillsDir, skill);
+    const dest = join2(agentsSkillsDir, skill);
+    mkdirSync(dest, { recursive: true });
+    cpSync(src, dest, { recursive: true });
+    const files = readdirSync2(src);
+    console.log(
+      `  ${skill}/ (${files.join(", ")})`
+    );
+  }
+  if (claude) {
+    const claudeSkillsDir = join2(
+      projectDir,
+      ".claude",
+      "skills"
+    );
+    mkdirSync(claudeSkillsDir, { recursive: true });
+    for (const skill of SKILL_DIRS) {
+      const linkPath = join2(claudeSkillsDir, skill);
+      const target = join2(
+        "..",
+        "..",
+        ".agents",
+        "skills",
+        skill
+      );
+      if (existsSync2(linkPath)) continue;
+      symlinkSync(target, linkPath);
+    }
+    console.log(
+      "\nCreated symlinks in .claude/skills/"
+    );
+  }
+  const docsAgentsDir = join2(
+    projectDir,
+    "docs",
+    "agents"
+  );
+  mkdirSync(docsAgentsDir, { recursive: true });
+  console.log("");
+  for (const tmpl of DOC_TEMPLATES) {
+    const dest = join2(docsAgentsDir, tmpl);
+    if (existsSync2(dest)) {
+      console.log(
+        `  docs/agents/${tmpl} (already exists)`
+      );
+      continue;
+    }
+    const src = join2(docsTemplatesDir, tmpl);
+    writeFileSync(dest, readFileSync(src, "utf8"));
+    console.log(`  docs/agents/${tmpl} (created)`);
+  }
+  const trackerSrc = join2(
+    docsTemplatesDir,
+    TRACKER_TEMPLATES[tracker]
+  );
+  const trackerDest = join2(docsAgentsDir, "issue-tracker.md");
+  writeFileSync(trackerDest, readFileSync(trackerSrc, "utf8"));
+  console.log(
+    `  docs/agents/issue-tracker.md (${tracker})`
+  );
+  const trackerLine = tracker === "github" ? "Issues are tracked via GitHub Issues using the `gh` CLI." : "Issues are tracked as local markdown files under `.scratch/`.";
+  const agentsMd = [
+    "## Agent skills",
+    "",
+    "### Issue tracker",
+    "",
+    `${trackerLine} See \`docs/agents/issue-tracker.md\`.`,
+    "",
+    "### Triage labels",
+    "",
+    "Default label vocabulary. See `docs/agents/triage-labels.md`.",
+    "",
+    "### Domain docs",
+    "",
+    "Single-context layout. See `docs/agents/domain.md`.",
+    ""
+  ].join("\n");
+  writeFileSync(join2(projectDir, "AGENTS.md"), agentsMd);
+  console.log("\n  AGENTS.md (updated)");
+  console.log(
+    `
+Source: ${upstream.repo} @ ${upstream.commit}`
+  );
+}
+
+// test/integration.test.ts
+function tmp() {
+  return mkdtempSync(
+    join3(tmpdir(), "nightralph-int-test-")
+  );
+}
+test("findFeatureDirs - no .scratch dir", (t) => {
+  const dir = tmp();
+  try {
+    const result = findFeatureDirs(dir);
+    t.deepEqual(
+      result,
+      [],
+      "returns empty array when .scratch/ missing"
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+test("findFeatureDirs - dirs without issues/", (t) => {
+  const dir = tmp();
+  try {
+    const scratch = join3(dir, ".scratch");
+    mkdirSync2(join3(scratch, "feat-a"), {
+      recursive: true
+    });
+    mkdirSync2(join3(scratch, "feat-b"), {
+      recursive: true
+    });
+    const result = findFeatureDirs(dir);
+    t.deepEqual(
+      result,
+      [],
+      "returns empty when no issues/ subdirs"
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+test("findFeatureDirs - valid feature dirs", (t) => {
+  const dir = tmp();
+  try {
+    const scratch = join3(dir, ".scratch");
+    mkdirSync2(
+      join3(scratch, "feat-x", "issues"),
+      { recursive: true }
+    );
+    writeFileSync2(
+      join3(scratch, "feat-x", "spec.md"),
+      "# spec"
+    );
+    const result = findFeatureDirs(dir);
+    t.equal(result.length, 1, "finds one feature");
+    t.equal(
+      result[0].name,
+      "feat-x",
+      "correct name"
+    );
+    t.equal(
+      result[0].dir,
+      join3(scratch, "feat-x", "issues"),
+      "correct dir path"
+    );
+    t.equal(
+      result[0].spec,
+      join3(scratch, "feat-x", "spec.md"),
+      "correct spec path"
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+test(
+  "findFeatureDirs - ignores non-directory entries",
+  (t) => {
+    const dir = tmp();
+    try {
+      const scratch = join3(dir, ".scratch");
+      mkdirSync2(scratch, { recursive: true });
+      writeFileSync2(
+        join3(scratch, "not-a-dir.txt"),
+        "just a file"
+      );
+      mkdirSync2(
+        join3(scratch, "real-feat", "issues"),
+        { recursive: true }
+      );
+      const result = findFeatureDirs(dir);
+      t.equal(
+        result.length,
+        1,
+        "only returns the directory entry"
+      );
+      t.equal(
+        result[0].name,
+        "real-feat",
+        "returns the valid feature"
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+);
+test(
+  "resolveIssuesDir - returns explicit flags directly",
+  async (t) => {
+    const dir = tmp();
+    try {
+      const result = await resolveIssuesDir(
+        "/my/issues",
+        "/my/spec.md",
+        dir
+      );
+      t.equal(
+        result.dir,
+        "/my/issues",
+        "dir matches the flag value"
+      );
+      t.equal(
+        result.spec,
+        "/my/spec.md",
+        "spec matches the flag value"
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+);
+test(
+  "resolveIssuesDir - no filesystem scanning with flags",
+  async (t) => {
+    const dir = tmp();
+    try {
+      const flagDir = join3(dir, "explicit-issues");
+      const flagSpec = join3(dir, "explicit-spec.md");
+      const result = await resolveIssuesDir(
+        flagDir,
+        flagSpec,
+        dir
+      );
+      t.equal(
+        result.dir,
+        flagDir,
+        "returns dir without scanning"
+      );
+      t.equal(
+        result.spec,
+        flagSpec,
+        "returns spec without scanning"
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+);
+var CLI = join3(process.cwd(), "dist", "index.js");
+var MOCK_AGENT = join3(
+  process.cwd(),
+  "test",
+  "mock-agent-pass.js"
+);
+var MOCK_ECHO = join3(
+  process.cwd(),
+  "test",
+  "mock-agent-echo-args.js"
+);
+function spawnCli(args) {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [CLI, ...args],
+      { timeout: 3e4 },
+      (err, stdout, stderr) => {
+        const code = err && "code" in err ? err.code : err ? 1 : 0;
+        resolve({
+          code,
+          stdout,
+          stderr
+        });
+      }
+    );
+  });
+}
+function makeTicketBody(opts) {
+  const lines = [
+    "# Test ticket",
+    "",
+    `**Status:** ${opts.status}`
+  ];
+  if (opts.blockers && opts.blockers.length > 0) {
+    lines.push(
+      `**Blocked by:** ${opts.blockers.join(", ")}`
+    );
+  }
+  return lines.join("\n");
+}
+test(
+  "CLI subprocess - --model flag forwarded to agent",
+  async (t) => {
+    const base = tmp();
+    try {
+      const issuesDir = join3(base, "issues");
+      const logsDir = join3(base, "logs");
+      mkdirSync2(issuesDir, { recursive: true });
+      const specPath = join3(base, "spec.md");
+      writeFileSync2(specPath, "# Test spec");
+      writeFileSync2(
+        join3(issuesDir, "01-echo.md"),
+        makeTicketBody({
+          status: "ready-for-agent"
+        })
+      );
+      const { code } = await spawnCli([
+        MOCK_ECHO,
+        "--dir",
+        issuesDir,
+        "--spec",
+        specPath,
+        "--timeout-secs",
+        "10",
+        "-m",
+        "test-model"
+      ]);
+      t.equal(code, 0, "exit code 0");
+      const logPath = join3(logsDir, "01-echo.log");
+      t.ok(
+        existsSync3(logPath),
+        "log file created"
+      );
+      const logContent = readFileSync2(
+        logPath,
+        "utf8"
+      );
+      t.ok(
+        logContent.includes("--model"),
+        "log contains --model flag"
+      );
+      t.ok(
+        logContent.includes("test-model"),
+        "log contains model value"
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+);
+test("CLI subprocess - --dry-run output", async (t) => {
+  const base = tmp();
+  try {
+    const issuesDir = join3(base, "issues");
+    mkdirSync2(issuesDir, { recursive: true });
+    const specPath = join3(base, "spec.md");
+    writeFileSync2(specPath, "# Test spec");
+    writeFileSync2(
+      join3(issuesDir, "01-alpha.md"),
+      makeTicketBody({ status: "ready-for-agent" })
+    );
+    writeFileSync2(
+      join3(issuesDir, "02-beta.md"),
+      makeTicketBody({
+        status: "ready-for-agent",
+        blockers: [1]
+      })
+    );
+    const { code, stdout } = await spawnCli([
+      MOCK_AGENT,
+      "--dir",
+      issuesDir,
+      "--spec",
+      specPath,
+      "--dry-run"
+    ]);
+    t.equal(code, 0, "exit code 0");
+    t.ok(
+      stdout.includes("Wave 1:") && stdout.includes("01-alpha.md"),
+      "stdout contains Wave 1 with first ticket"
+    );
+    t.ok(
+      stdout.includes("Wave 2:") && stdout.includes("02-beta.md"),
+      "stdout contains Wave 2 with second ticket"
+    );
+    t.ok(
+      stdout.includes("AGENT INSTRUCTIONS"),
+      "stdout contains prompt preview"
+    );
+    const ticket1 = readFileSync2(
+      join3(issuesDir, "01-alpha.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket1.includes("**Status:** ready-for-agent"),
+      "ticket 1 NOT modified"
+    );
+    const ticket2 = readFileSync2(
+      join3(issuesDir, "02-beta.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket2.includes("**Status:** ready-for-agent"),
+      "ticket 2 NOT modified"
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test(
+  "CLI subprocess - no tickets exits gracefully",
+  async (t) => {
+    const base = tmp();
+    try {
+      const issuesDir = join3(base, "issues");
+      mkdirSync2(issuesDir, { recursive: true });
+      const specPath = join3(base, "spec.md");
+      writeFileSync2(specPath, "# Empty spec");
+      const { code, stdout } = await spawnCli([
+        MOCK_AGENT,
+        "--dir",
+        issuesDir,
+        "--spec",
+        specPath
+      ]);
+      t.equal(code, 0, "exit code 0 (graceful)");
+      t.ok(
+        stdout.includes("No ticket files found"),
+        "stdout contains no-tickets message"
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+);
+test("CLI subprocess - error for missing --dir", async (t) => {
+  const base = tmp();
+  try {
+    const specPath = join3(base, "spec.md");
+    writeFileSync2(specPath, "# Valid spec");
+    const { code, stderr } = await spawnCli([
+      MOCK_AGENT,
+      "--dir",
+      "/nonexistent/path",
+      "--spec",
+      specPath
+    ]);
+    t.ok(code !== 0, "exit code is non-zero");
+    t.ok(
+      stderr.includes("not found"),
+      "stderr contains not found"
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test("CLI subprocess - error for missing --spec", async (t) => {
+  const base = tmp();
+  try {
+    const issuesDir = join3(base, "issues");
+    mkdirSync2(issuesDir, { recursive: true });
+    const { code, stderr } = await spawnCli([
+      MOCK_AGENT,
+      "--dir",
+      issuesDir,
+      "--spec",
+      "/nonexistent/spec.md"
+    ]);
+    t.ok(code !== 0, "exit code is non-zero");
+    t.ok(
+      stderr.includes("not found"),
+      "stderr contains not found"
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+test(
+  "CLI subprocess - unknown blocker warning and stripping",
+  async (t) => {
+    const base = tmp();
+    try {
+      const issuesDir = join3(base, "issues");
+      const logsDir = join3(base, "logs");
+      mkdirSync2(issuesDir, { recursive: true });
+      const specPath = join3(base, "spec.md");
+      writeFileSync2(specPath, "# Test spec");
+      writeFileSync2(
+        join3(issuesDir, "01-task.md"),
+        makeTicketBody({
+          status: "ready-for-agent",
+          blockers: [99]
+        })
+      );
+      const { code, stdout, stderr } = await spawnCli([
+        MOCK_AGENT,
+        "--dir",
+        issuesDir,
+        "--spec",
+        specPath,
+        "--timeout-secs",
+        "10"
+      ]);
+      const combined = stdout + stderr;
+      t.ok(
+        combined.includes("99"),
+        "output warns about blocker 99"
+      );
+      t.ok(
+        combined.includes("not found"),
+        "output mentions blocker not found"
+      );
+      t.equal(code, 0, "exit code 0");
+      const ticket = readFileSync2(
+        join3(issuesDir, "01-task.md"),
+        "utf8"
+      );
+      t.ok(
+        ticket.includes("**Status:** done"),
+        "ticket completed after blocker stripped"
+      );
+      t.ok(
+        existsSync3(join3(logsDir, "01-task.log")),
+        "log file created"
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+);
+test(
+  "CLI subprocess - dry-run deadlock detection",
+  async (t) => {
+    const base = tmp();
+    try {
+      const issuesDir = join3(base, "issues");
+      mkdirSync2(issuesDir, { recursive: true });
+      const specPath = join3(base, "spec.md");
+      writeFileSync2(specPath, "# Test spec");
+      writeFileSync2(
+        join3(issuesDir, "01-alpha.md"),
+        makeTicketBody({
+          status: "ready-for-agent",
+          blockers: [2]
+        })
+      );
+      writeFileSync2(
+        join3(issuesDir, "02-beta.md"),
+        makeTicketBody({
+          status: "ready-for-agent",
+          blockers: [1]
+        })
+      );
+      const { code, stdout } = await spawnCli([
+        MOCK_AGENT,
+        "--dir",
+        issuesDir,
+        "--spec",
+        specPath,
+        "--dry-run"
+      ]);
+      t.equal(code, 0, "exit code 0");
+      t.ok(
+        stdout.includes("Deadlocked tickets"),
+        "output contains Deadlocked tickets"
+      );
+      t.ok(
+        stdout.includes("01-alpha.md"),
+        "deadlock lists first ticket"
+      );
+      t.ok(
+        stdout.includes("02-beta.md"),
+        "deadlock lists second ticket"
+      );
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+);
+test("CLI subprocess - execute smoke test", async (t) => {
+  const base = tmp();
+  try {
+    const issuesDir = join3(base, "issues");
+    const logsDir = join3(base, "logs");
+    mkdirSync2(issuesDir, { recursive: true });
+    const specPath = join3(base, "spec.md");
+    writeFileSync2(specPath, "# Test spec\nDo things.");
+    writeFileSync2(
+      join3(issuesDir, "01-first.md"),
+      makeTicketBody({ status: "ready-for-agent" })
+    );
+    writeFileSync2(
+      join3(issuesDir, "02-second.md"),
+      makeTicketBody({
+        status: "ready-for-agent",
+        blockers: [1]
+      })
+    );
+    const { code } = await spawnCli([
+      MOCK_AGENT,
+      "--dir",
+      issuesDir,
+      "--spec",
+      specPath,
+      "--timeout-secs",
+      "10"
+    ]);
+    t.equal(code, 0, "exit code 0");
+    const ticket1 = readFileSync2(
+      join3(issuesDir, "01-first.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket1.includes("**Status:** done"),
+      "ticket 1 marked done"
+    );
+    const ticket2 = readFileSync2(
+      join3(issuesDir, "02-second.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket2.includes("**Status:** done"),
+      "ticket 2 marked done"
+    );
+    t.ok(
+      existsSync3(join3(logsDir, "01-first.log")),
+      "log file created for ticket 1"
+    );
+    t.ok(
+      existsSync3(join3(logsDir, "02-second.log")),
+      "log file created for ticket 2"
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+var DIST_DIR = join3(process.cwd(), "dist");
+test("setup-then-execute composition", async (t) => {
+  const projectDir = tmp();
+  try {
+    setup({
+      bundledSkillsDir: join3(DIST_DIR, "skills"),
+      docsTemplatesDir: join3(
+        DIST_DIR,
+        "docs-templates"
+      ),
+      projectDir,
+      tracker: "local"
+    });
+    const feature = "my-feature";
+    const issuesDir = join3(
+      projectDir,
+      ".scratch",
+      feature,
+      "issues"
+    );
+    const specPath = join3(
+      projectDir,
+      ".scratch",
+      feature,
+      "spec.md"
+    );
+    mkdirSync2(issuesDir, { recursive: true });
+    writeFileSync2(specPath, "# Feature spec\nDo things.");
+    writeFileSync2(
+      join3(issuesDir, "01-alpha.md"),
+      makeTicketBody({ status: "ready-for-agent" })
+    );
+    writeFileSync2(
+      join3(issuesDir, "02-beta.md"),
+      makeTicketBody({
+        status: "ready-for-agent",
+        blockers: [1]
+      })
+    );
+    const { code } = await spawnCli([
+      MOCK_AGENT,
+      "--dir",
+      issuesDir,
+      "--spec",
+      specPath,
+      "--timeout-secs",
+      "10"
+    ]);
+    t.equal(code, 0, "exit code 0");
+    const ticket1 = readFileSync2(
+      join3(issuesDir, "01-alpha.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket1.includes("**Status:** done"),
+      "ticket 1 marked done"
+    );
+    const ticket2 = readFileSync2(
+      join3(issuesDir, "02-beta.md"),
+      "utf8"
+    );
+    t.ok(
+      ticket2.includes("**Status:** done"),
+      "ticket 2 marked done"
+    );
+    const logsDir = join3(
+      projectDir,
+      ".scratch",
+      feature,
+      "logs"
+    );
+    t.ok(
+      existsSync3(join3(logsDir, "01-alpha.log")),
+      "log file created for ticket 1"
+    );
+    t.ok(
+      existsSync3(join3(logsDir, "02-beta.log")),
+      "log file created for ticket 2"
+    );
+    t.ok(
+      existsSync3(join3(
+        projectDir,
+        "docs",
+        "agents",
+        "issue-tracker.md"
+      )),
+      "docs/agents/issue-tracker.md exists from setup"
+    );
+    for (const skill of SKILL_DIRS) {
+      t.ok(
+        existsSync3(join3(
+          projectDir,
+          ".agents",
+          "skills",
+          skill
+        )),
+        `.agents/skills/${skill}/ exists from setup`
+      );
+    }
+  } finally {
+    rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+//# sourceMappingURL=integration.test.js.map