@moreih29/nexus-core 0.13.0 → 0.14.0

package/scripts/cli.test.ts

@@ -1,367 +0,0 @@
-/**
- * scripts/cli.test.ts
- *
- * Unit tests for scripts/cli.ts
- *
- * Scenarios:
- *  (1) parseFlags — flag parsing for all recognized flags
- *  (2) main() routing — each subcommand dispatches correctly
- *  (3) runList() — returns correct agent/skill/hook counts
- *  (4) runValidateSync() — passes on real assets
- *  (5) runValidateSync() — catches missing required fields
- *  (6) main() unknown command — exits with error
- */
-
-import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
-import {
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import {
-  parseFlags,
-  collectListEntries,
-  runValidateSync,
-  main,
-  ROOT,
-  type ParsedFlags,
-} from "./cli.js";
-
-// ---------------------------------------------------------------------------
-// (1) parseFlags
-// ---------------------------------------------------------------------------
-
-describe("parseFlags", () => {
-  test("defaults when no args", () => {
-    const flags = parseFlags([]);
-    expect(flags.dryRun).toBe(false);
-    expect(flags.force).toBe(false);
-    expect(flags.strict).toBe(false);
-    expect(flags.help).toBe(false);
-    expect(flags.harness).toBeUndefined();
-    expect(flags.target).toBeUndefined();
-    expect(flags.only).toBeUndefined();
-    expect(flags.remaining).toEqual([]);
-  });
-
-  test("--dry-run", () => {
-    const flags = parseFlags(["--dry-run"]);
-    expect(flags.dryRun).toBe(true);
-  });
-
-  test("--force", () => {
-    const flags = parseFlags(["--force"]);
-    expect(flags.force).toBe(true);
-  });
-
-  test("--strict", () => {
-    const flags = parseFlags(["--strict"]);
-    expect(flags.strict).toBe(true);
-  });
-
-  test("--help", () => {
-    const flags = parseFlags(["--help"]);
-    expect(flags.help).toBe(true);
-  });
-
-  test("-h short alias", () => {
-    const flags = parseFlags(["-h"]);
-    expect(flags.help).toBe(true);
-  });
-
-  test("--harness=claude", () => {
-    const flags = parseFlags(["--harness=claude"]);
-    expect(flags.harness).toBe("claude");
-  });
-
-  test("--target resolves to absolute path", () => {
-    const flags = parseFlags(["--target=/tmp/test-dir"]);
-    expect(flags.target).toBe("/tmp/test-dir");
-  });
-
-  test("--only=engineer", () => {
-    const flags = parseFlags(["--only=engineer"]);
-    expect(flags.only).toBe("engineer");
-  });
-
-  test("unknown args go to remaining", () => {
-    const flags = parseFlags(["--unknown-flag", "positional"]);
-    expect(flags.remaining).toContain("--unknown-flag");
-    expect(flags.remaining).toContain("positional");
-  });
-
-  test("multiple flags together", () => {
-    const flags = parseFlags([
-      "--harness=opencode",
-      "--target=/tmp/out",
-      "--dry-run",
-      "--force",
-      "--strict",
-      "--only=architect",
-    ]);
-    expect(flags.harness).toBe("opencode");
-    expect(flags.target).toBe("/tmp/out");
-    expect(flags.dryRun).toBe(true);
-    expect(flags.force).toBe(true);
-    expect(flags.strict).toBe(true);
-    expect(flags.only).toBe("architect");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// (2) main() routing — help messages
-// ---------------------------------------------------------------------------
-
-describe("main() routing", () => {
-  test("--help prints help without error", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    const output = lines.join("\n");
-    expect(output).toContain("nexus-core");
-    expect(output).toContain("sync");
-    expect(output).toContain("init");
-    expect(output).toContain("list");
-    expect(output).toContain("validate");
-    expect(output).toContain("mcp");
-  });
-
-  test("no args prints help without error", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main([]);
-    } finally {
-      console.log = origLog;
-    }
-
-    expect(lines.join("\n")).toContain("nexus-core");
-  });
-
-  test("sync --help prints sync help", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["sync", "--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    const output = lines.join("\n");
-    expect(output).toContain("--harness");
-    expect(output).toContain("--target");
-    expect(output).toContain("--dry-run");
-  });
-
-  test("init --help prints init help", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["init", "--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    expect(lines.join("\n")).toContain("--target");
-  });
-
-  test("list --help prints list help", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["list", "--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    expect(lines.join("\n")).toContain("list");
-  });
-
-  test("validate --help prints validate help", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["validate", "--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    expect(lines.join("\n")).toContain("validate");
-  });
-
-  test("mcp --help prints mcp help", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["mcp", "--help"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    expect(lines.join("\n")).toContain("mcp");
-  });
-
-  test("unknown command exits with code 1", async () => {
-    const origExit = process.exit;
-    let exitCode: number | undefined;
-    // @ts-ignore — mock process.exit
-    process.exit = (code?: number) => {
-      exitCode = code;
-      throw new Error(`process.exit(${code})`);
-    };
-
-    try {
-      await main(["unknowncmd"]);
-    } catch {
-      // expected
-    } finally {
-      process.exit = origExit;
-    }
-
-    expect(exitCode).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// (3) collectListEntries — real assets
-// ---------------------------------------------------------------------------
-
-describe("collectListEntries (real assets)", () => {
-  test("returns 10 agents from assets/agents/", () => {
-    const entries = collectListEntries();
-    const agents = entries.filter((e) => e.kind === "agent");
-    expect(agents.length).toBe(10);
-  });
-
-  test("returns 4 skills from assets/skills/", () => {
-    const entries = collectListEntries();
-    const skills = entries.filter((e) => e.kind === "skill");
-    expect(skills.length).toBe(4);
-  });
-
-  test("returns hooks from assets/hooks/", () => {
-    const entries = collectListEntries();
-    const hooks = entries.filter((e) => e.kind === "hook");
-    expect(hooks.length).toBeGreaterThan(0);
-  });
-
-  test("each agent entry has a name and description", () => {
-    const entries = collectListEntries();
-    const agents = entries.filter((e) => e.kind === "agent");
-    for (const a of agents) {
-      expect(a.name.length).toBeGreaterThan(0);
-      expect(typeof a.description).toBe("string");
-    }
-  });
-
-  test("known agent 'engineer' is present", () => {
-    const entries = collectListEntries();
-    const engineer = entries.find((e) => e.kind === "agent" && e.name === "engineer");
-    expect(engineer).toBeDefined();
-    expect(engineer?.description).toContain("Implementation");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// (4) runValidateSync — real assets pass
-// ---------------------------------------------------------------------------
-
-describe("runValidateSync (real assets)", () => {
-  test("passes with no errors on current assets", () => {
-    const result = runValidateSync();
-    expect(result.errors).toEqual([]);
-    expect(result.ok).toBe(true);
-    expect(result.checked).toBeGreaterThan(0);
-  });
-
-  test("checked count equals agents + skills + 2 YAML files", () => {
-    const result = runValidateSync();
-    // 9 agents + 4 skills + capability-matrix.yml + tool-name-map.yml = 15
-    expect(result.checked).toBeGreaterThanOrEqual(15);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// (5) runValidateSync — error detection on bad assets
-// ---------------------------------------------------------------------------
-
-describe("runValidateSync (bad assets in tmp)", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "nexus-cli-validate-"));
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test("detects missing frontmatter in agent body.md", () => {
-    // Create a fake agents dir entry with malformed body.md
-    const agentsDir = join(tmpDir, "agents", "bad-agent");
-    mkdirSync(agentsDir, { recursive: true });
-    writeFileSync(join(agentsDir, "body.md"), "no frontmatter here\n");
-
-    // We test the parseFrontmatterRaw logic indirectly by verifying
-    // that a real body.md without --- delimiters is detected as invalid
-    const { parseFrontmatterRaw: _unused, ...rest } = {
-      parseFrontmatterRaw: null,
-    };
-
-    // Validate using real assets — the real check should still pass
-    const result = runValidateSync();
-    expect(result.ok).toBe(true);
-  });
-
-  test("runValidateSync passes when no errors on real repo", () => {
-    const result = runValidateSync();
-    expect(result.ok).toBe(true);
-    expect(result.errors.length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// (6) runList output
-// ---------------------------------------------------------------------------
-
-describe("runList output", () => {
-  test("prints agents header with count 9", async () => {
-    const lines: string[] = [];
-    const origLog = console.log;
-    console.log = (...args: unknown[]) => lines.push(args.join(" "));
-
-    try {
-      await main(["list"]);
-    } finally {
-      console.log = origLog;
-    }
-
-    const output = lines.join("\n");
-    expect(output).toContain("Agents (10)");
-    expect(output).toContain("Skills (4)");
-    expect(output).toContain("Hooks");
-  });
-});