AgentHub/server/__tests__/lane-agents.test.js

/**
 * @file Tests for lane-agents.js: agent-template installation into a lane's
 * .claude/agents/, including path resolution, git-exclude idempotence, and
 * missing-repo rejection.
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */

const { execFileSync } = require("node:child_process");
const os = require("node:os");
const path = require("node:path");
const fs = require("node:fs");

const SUITE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "agenthub-lane-agents-"));
process.env.DASHBOARD_DB_PATH = path.join(SUITE_ROOT, "dashboard.db");
process.env.LANES_ROOT = path.join(SUITE_ROOT, "lanes");

const { describe, it, after } = require("node:test");
const assert = require("node:assert/strict");

const lanesLib = require("../lib/lanes");
const { installAgents, removeStageDoc } = require("../lib/lane-agents");

after(() => fs.rmSync(SUITE_ROOT, { recursive: true, force: true }));

// Strip GIT_* vars a parent git hook (e.g. the pre-commit hook running this
// very suite) sets in its own environment — those leak to every child
// process and override an explicit `cwd`, so without this `git init` here
// operates on the outer repo's .git instead of this fixture's throwaway one.
// Same scrub `lanes-cli.test.js` and `worktree.js`'s own git() helper use.
const GIT_ENV = { ...process.env };
delete GIT_ENV.GIT_DIR;
delete GIT_ENV.GIT_WORK_TREE;
delete GIT_ENV.GIT_INDEX_FILE;
delete GIT_ENV.GIT_COMMON_DIR;
delete GIT_ENV.GIT_OBJECT_DIRECTORY;
delete GIT_ENV.GIT_ALTERNATE_OBJECT_DIRECTORIES;
delete GIT_ENV.GIT_PREFIX;
delete GIT_ENV.GIT_NAMESPACE;
delete GIT_ENV.GIT_CONFIG_PARAMETERS;

let laneSeq = 0;

/** Create a real git repo dir (used as a lane's cwd). */
function makeRepoDir() {
  const cwd = path.join(SUITE_ROOT, `repo-${++laneSeq}`);
  fs.mkdirSync(cwd, { recursive: true });
  execFileSync("git", ["init", "--initial-branch=main"], { cwd, stdio: "pipe", env: GIT_ENV });
  return cwd;
}

/** Create a lane record backed by an existing directory. */
function makeLane(cwd) {
  return lanesLib.createLane({ title: "agents-test", cwd, kind: "managed" });
}

describe("installAgents", () => {
  it("copies agent templates from agents/ dir into lane's .claude/agents/", async () => {
    const cwd = makeRepoDir();
    const lane = makeLane(cwd);
    const result = await installAgents(lane);

    assert.deepEqual([...result.installed].sort(), ["qc-local.md", "senior-gate-reviewer.md"]);
    assert.ok(fs.existsSync(path.join(cwd, ".claude", "agents", "qc-local.md")));
    assert.ok(fs.existsSync(path.join(cwd, ".claude", "agents", "senior-gate-reviewer.md")));

    // Verify the source path is new (agents/) not old (data/agent-templates/)
    const oldPath = path.join(__dirname, "..", "data", "agent-templates", "ship-feature-lane");
    assert.equal(fs.existsSync(oldPath), false);
  });

  it("throws ENOTGITREPO when lane cwd has no .git", async () => {
    const cwd = path.join(SUITE_ROOT, "no-git");
    fs.mkdirSync(cwd, { recursive: true });
    const lane = makeLane(cwd);
    await assert.rejects(
      () => installAgents(lane),
      (err) => err.code === "ENOTGITREPO"
    );
  });

  it("adds .claude/agents/ line to git info/exclude idempotently", async () => {
    const cwd = makeRepoDir();
    const lane = makeLane(cwd);

    await installAgents(lane); // first
    await installAgents(lane); // reinstall — should not duplicate

    const excludePath = path.join(cwd, ".git", "info", "exclude");
    const content = fs.readFileSync(excludePath, "utf8");
    const matches = content.split("\n").filter((l) => l === ".claude/agents/");
    assert.equal(matches.length, 1);
  });

  it("overwrites existing agents on reinstall", async () => {
    const cwd = makeRepoDir();
    const lane = makeLane(cwd);

    await installAgents(lane);

    // Tamper with the installed file
    const agentPath = path.join(cwd, ".claude", "agents", "qc-local.md");
    fs.writeFileSync(agentPath, "tampered");

    // Reinstall
    await installAgents(lane);
    const content = fs.readFileSync(agentPath, "utf8");
    assert.ok(content.includes("#"), "reinstalled file should look like markdown, not 'tampered'");
    assert.notEqual(content, "tampered");
  });

  it("creates .claude/agents/ dir if it does not exist", async () => {
    const cwd = makeRepoDir();
    const lane = makeLane(cwd);
    assert.equal(fs.existsSync(path.join(cwd, ".claude", "agents")), false);
    await installAgents(lane);
    assert.ok(fs.existsSync(path.join(cwd, ".claude", "agents")));
  });

  it("installs nothing for a codex lane — no .claude/agents/, no AGENTS.md", async () => {
    const cwd = makeRepoDir();
    const lane = lanesLib.createLane({ title: "cx", cwd, kind: "managed", tool: "codex" });

    const result = await installAgents(lane);
    assert.deepEqual(result.installed, []);
    assert.equal(fs.existsSync(path.join(cwd, ".claude", "agents")), false);
    assert.equal(fs.existsSync(path.join(cwd, "AGENTS.md")), false);
  });
});

describe("codex pipeline cleanup", () => {
  const START = "<!-- agenthub:stage:start -->";
  const END = "<!-- agenthub:stage:end -->";
  const BLOCK = `${START}\n## Declare your lane stage as you work\n\nagenthub stage …\n${END}\n`;

  it("removes only the AgentHub block, keeping the user's own AGENTS.md prose", () => {
    const cwd = makeRepoDir();
    const file = path.join(cwd, "AGENTS.md");
    fs.writeFileSync(file, `# House rules\n\nNever force-push.\n\n${BLOCK}\n## More\n\nKeep me.\n`);

    assert.equal(removeStageDoc(cwd), true);
    const doc = fs.readFileSync(file, "utf8");
    assert.ok(!doc.includes(START) && !doc.includes(END));
    assert.match(doc, /Never force-push\./);
    assert.match(doc, /Keep me\./);
  });

  it("deletes an AGENTS.md that held nothing but the block", () => {
    const cwd = makeRepoDir();
    fs.writeFileSync(path.join(cwd, "AGENTS.md"), BLOCK);
    assert.equal(removeStageDoc(cwd), true);
    assert.equal(fs.existsSync(path.join(cwd, "AGENTS.md")), false);
  });

  it("leaves a file without the block, or no file at all, untouched", () => {
    const cwd = makeRepoDir();
    assert.equal(removeStageDoc(cwd), false);
    fs.writeFileSync(path.join(cwd, "AGENTS.md"), "# Mine\n");
    assert.equal(removeStageDoc(cwd), false);
    assert.equal(fs.readFileSync(path.join(cwd, "AGENTS.md"), "utf8"), "# Mine\n");
  });

  it("wipes a codex lane's stage, detection, stage log and features — and no claude lane's", () => {
    const codex = lanesLib.createLane({ title: "cx", cwd: makeRepoDir(), tool: "codex" });
    const claude = lanesLib.createLane({ title: "cc", cwd: makeRepoDir(), tool: "claude" });
    for (const lane of [codex, claude]) {
      lanesLib.setStage(lane.id, { stage: "tests", evidence: "old" });
      lanesLib.recordDetection(lane.id, { nodeId: "review", signal: "npm test" });
    }
    const { db } = require("../db");
    const insertFeature = db.prepare("INSERT INTO lane_features (lane_id, slug) VALUES (?, ?)");
    insertFeature.run(codex.id, "old-feature");
    insertFeature.run(claude.id, "kept-feature");

    assert.equal(lanesLib.clearCodexPipelines(), 1);

    const cx = lanesLib.getLane(codex.id);
    assert.equal(cx.stage, "idle");
    assert.deepEqual(cx.stages, {});
    assert.equal(cx.detected_stage, null);
    const count = (table, id) =>
      db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE lane_id = ?`).get(id).n;
    assert.equal(count("lane_stage_events", codex.id), 0);
    assert.equal(count("lane_features", codex.id), 0);

    const cc = lanesLib.getLane(claude.id);
    assert.equal(cc.stage, "tests");
    assert.ok(count("lane_stage_events", claude.id) > 0);
    assert.equal(count("lane_features", claude.id), 1);

    assert.equal(lanesLib.clearCodexPipelines(), 0); // idempotent
  });
});