@codemcp/ade-cli 0.0.2

package/src/commands/conventions.integration.spec.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile, access } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  select: vi.fn(),
+  multiselect: vi.fn(),
+  confirm: vi.fn(),
+  isCancel: vi.fn().mockReturnValue(false),
+  cancel: vi.fn(),
+  spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
+}));
+
+import * as clack from "@clack/prompts";
+import { runSetup } from "./setup.js";
+import { readUserConfig, readLockFile } from "@codemcp/ade-core";
+import { getDefaultCatalog } from "../../../core/src/catalog/index.js";
+
+describe("architecture and practices facets integration", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    dir = await mkdtemp(join(tmpdir(), "ade-conventions-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it(
+    "writes SKILL.md files and installs inline skills for tanstack architecture",
+    { timeout: 60_000 },
+    async () => {
+      const catalog = getDefaultCatalog();
+
+      // Facet order: process (select), architecture (select), practices (multiselect)
+      vi.mocked(clack.select)
+        .mockResolvedValueOnce("codemcp-workflows") // process
+        .mockResolvedValueOnce("tanstack"); // architecture
+      vi.mocked(clack.multiselect)
+        .mockResolvedValueOnce([]) // practices: none
+        .mockResolvedValueOnce([]) // backpressure: none
+        .mockResolvedValueOnce([]) // docsets: deselect all
+        .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+      await runSetup(dir, catalog);
+
+      // Inline skills should have SKILL.md in .ade/skills/ (staging area)
+      for (const skill of [
+        "tanstack-architecture",
+        "tanstack-design",
+        "tanstack-code",
+        "tanstack-testing"
+      ]) {
+        const skillMd = await readFile(
+          join(dir, ".ade", "skills", skill, "SKILL.md"),
+          "utf-8"
+        );
+        expect(skillMd).toContain(`name: ${skill}`);
+        expect(skillMd).toContain("---");
+      }
+
+      // Inline skills should also be installed to .agentskills/skills/ by runAdd
+      for (const skill of [
+        "tanstack-architecture",
+        "tanstack-design",
+        "tanstack-code",
+        "tanstack-testing"
+      ]) {
+        const installed = await readFile(
+          join(dir, ".agentskills", "skills", skill, "SKILL.md"),
+          "utf-8"
+        );
+        expect(installed).toContain(`name: ${skill}`);
+      }
+
+      // skills-lock.json should be created by runAdd
+      const lockRaw = await readFile(join(dir, "skills-lock.json"), "utf-8");
+      const skillsLock = JSON.parse(lockRaw);
+      expect(skillsLock.skills).toBeDefined();
+
+      // skills-server MCP server should be in .mcp.json
+      const mcpJson = JSON.parse(
+        await readFile(join(dir, ".mcp.json"), "utf-8")
+      );
+      expect(mcpJson.mcpServers["agentskills"]).toMatchObject({
+        command: "npx",
+        args: ["-y", "@codemcp/skills-server"]
+      });
+    }
+  );
+
+  it("writes skills for multiple selected practices", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Facet order: process (select), architecture (select), practices (multiselect)
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("native-agents-md") // process
+      .mockResolvedValueOnce("__skip__"); // architecture: skip
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce(["conventional-commits", "tdd-london"]) // practices
+      .mockResolvedValueOnce([]) // docsets: deselect all (conventional-commits has docset)
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+    await runSetup(dir, catalog);
+
+    // Both inline skills should exist in .ade/skills/ (staging)
+    const commits = await readFile(
+      join(dir, ".ade", "skills", "conventional-commits", "SKILL.md"),
+      "utf-8"
+    );
+    expect(commits).toContain("name: conventional-commits");
+    expect(commits).toContain("Conventional Commits");
+
+    const tdd = await readFile(
+      join(dir, ".ade", "skills", "tdd-london", "SKILL.md"),
+      "utf-8"
+    );
+    expect(tdd).toContain("name: tdd-london");
+    expect(tdd).toContain("London");
+
+    // Both should be installed to .agentskills/skills/
+    await expect(
+      access(join(dir, ".agentskills", "skills", "conventional-commits"))
+    ).resolves.toBeUndefined();
+    await expect(
+      access(join(dir, ".agentskills", "skills", "tdd-london"))
+    ).resolves.toBeUndefined();
+
+    // config.yaml should have array of choices under practices
+    const config = await readUserConfig(dir);
+    expect(config!.choices.practices).toEqual([
+      "conventional-commits",
+      "tdd-london"
+    ]);
+
+    // Lock file should reflect both
+    const lock = await readLockFile(dir);
+    expect(lock!.logical_config.skills.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("writes ADR skill with template content", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Facet order: process (select), architecture (select), practices (multiselect)
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("native-agents-md") // process
+      .mockResolvedValueOnce("__skip__"); // architecture: skip
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce(["adr-nygard"])
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+    await runSetup(dir, catalog);
+
+    const adr = await readFile(
+      join(dir, ".ade", "skills", "adr-nygard", "SKILL.md"),
+      "utf-8"
+    );
+    expect(adr).toContain("name: adr-nygard");
+    expect(adr).toContain("## Context");
+    expect(adr).toContain("## Decision");
+    expect(adr).toContain("## Consequences");
+  });
+
+  it("skips both architecture and practices when none selected", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Facet order: process (select), architecture (select), practices (multiselect)
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("native-agents-md") // process
+      .mockResolvedValueOnce("__skip__"); // architecture: skip
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce([]) // practices: none
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+    await runSetup(dir, catalog);
+
+    // No .ade directory should exist
+    await expect(access(join(dir, ".ade"))).rejects.toThrow();
+
+    // config.yaml should not have architecture or practices keys
+    const config = await readUserConfig(dir);
+    expect(config!.choices).not.toHaveProperty("architecture");
+    expect(config!.choices).not.toHaveProperty("practices");
+  });
+
+  it("exposes practices as skills, not instructions", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Facet order: process (select), architecture (select), practices (multiselect)
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("native-agents-md") // process
+      .mockResolvedValueOnce("__skip__"); // architecture: skip
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce(["tdd-london"])
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+    await runSetup(dir, catalog);
+
+    // Practice produces a skill, not an instruction
+    const skillMd = await readFile(
+      join(dir, ".ade", "skills", "tdd-london", "SKILL.md"),
+      "utf-8"
+    );
+    expect(skillMd).toContain("name: tdd-london");
+
+    // Lock file should have skill but no practice-specific instructions
+    const lock = await readLockFile(dir);
+    expect(lock!.logical_config.skills.length).toBeGreaterThanOrEqual(1);
+    // Only process-facet instructions should be present (from native-agents-md)
+    for (const instruction of lock!.logical_config.instructions) {
+      expect(instruction).not.toContain("tdd-london");
+    }
+  });
+
+  it(
+    "combines architecture and practices selections",
+    { timeout: 60_000 },
+    async () => {
+      const catalog = getDefaultCatalog();
+
+      // Facet order: process (select), architecture (select), practices (multiselect)
+      vi.mocked(clack.select)
+        .mockResolvedValueOnce("codemcp-workflows") // process
+        .mockResolvedValueOnce("tanstack"); // architecture
+      vi.mocked(clack.multiselect)
+        .mockResolvedValueOnce(["tdd-london", "conventional-commits"]) // practices
+        .mockResolvedValueOnce([]) // backpressure: none
+        .mockResolvedValueOnce([]) // docsets: deselect all
+        .mockResolvedValueOnce(["claude-code"]); // harnesses
+
+      await runSetup(dir, catalog);
+
+      // Architecture skills should exist
+      const archSkill = await readFile(
+        join(dir, ".ade", "skills", "tanstack-architecture", "SKILL.md"),
+        "utf-8"
+      );
+      expect(archSkill).toContain("name: tanstack-architecture");
+
+      // Practice skills should exist
+      const tddSkill = await readFile(
+        join(dir, ".ade", "skills", "tdd-london", "SKILL.md"),
+        "utf-8"
+      );
+      expect(tddSkill).toContain("name: tdd-london");
+
+      const commitsSkill = await readFile(
+        join(dir, ".ade", "skills", "conventional-commits", "SKILL.md"),
+        "utf-8"
+      );
+      expect(commitsSkill).toContain("name: conventional-commits");
+
+      // config.yaml should have both architecture and practices
+      const config = await readUserConfig(dir);
+      expect(config!.choices.architecture).toBe("tanstack");
+      expect(config!.choices.practices).toEqual([
+        "tdd-london",
+        "conventional-commits"
+      ]);
+    }
+  );
+});

package/src/commands/install.integration.spec.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Mock only the TUI — everything else is real
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+  select: vi.fn(),
+  multiselect: vi.fn(),
+  isCancel: vi.fn().mockReturnValue(false),
+  cancel: vi.fn(),
+  spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
+}));
+
+import * as clack from "@clack/prompts";
+import { runSetup } from "./setup.js";
+import { runInstall } from "./install.js";
+import { getDefaultCatalog } from "../../../core/src/catalog/index.js";
+
+describe("install integration (real temp dir)", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    dir = await mkdtemp(join(tmpdir(), "ade-install-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("applies lock file to regenerate agent files without re-resolving", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Step 1: Run setup to create config.yaml + config.lock.yaml
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("codemcp-workflows") // process
+      .mockResolvedValueOnce("__skip__"); // architecture
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce([]) // practices: none
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+    await runSetup(dir, catalog);
+
+    // Step 2: Delete agent output files to simulate a fresh clone
+    await rm(join(dir, ".mcp.json"));
+    await rm(join(dir, ".claude"), { recursive: true, force: true });
+
+    // Step 3: Run install — should regenerate from config.lock.yaml
+    await runInstall(dir, ["claude-code"]);
+
+    // Agent files should be back
+    const agentMd = await readFile(
+      join(dir, ".claude", "agents", "ade.md"),
+      "utf-8"
+    );
+    expect(agentMd).toContain("Call whats_next()");
+
+    const mcpJson = JSON.parse(await readFile(join(dir, ".mcp.json"), "utf-8"));
+    expect(mcpJson.mcpServers["workflows"]).toMatchObject({
+      command: "npx",
+      args: ["@codemcp/workflows-server@latest"]
+    });
+  });
+
+  it("does not modify the lock file", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Setup first
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("codemcp-workflows") // process
+      .mockResolvedValueOnce("__skip__"); // architecture
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce([]) // practices: none
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+    await runSetup(dir, catalog);
+
+    const lockRawBefore = await readFile(
+      join(dir, "config.lock.yaml"),
+      "utf-8"
+    );
+
+    // Re-install
+    await runInstall(dir, ["claude-code"]);
+
+    const lockRawAfter = await readFile(join(dir, "config.lock.yaml"), "utf-8");
+    // Lock file should be byte-identical (install doesn't rewrite it)
+    expect(lockRawAfter).toBe(lockRawBefore);
+  });
+
+  it("fails when no config.lock.yaml exists", async () => {
+    await expect(runInstall(dir, ["claude-code"])).rejects.toThrow(
+      /config\.lock\.yaml not found/i
+    );
+  });
+
+  it("works with native-agents-md option", async () => {
+    const catalog = getDefaultCatalog();
+
+    // Setup with native-agents-md
+    vi.mocked(clack.select)
+      .mockResolvedValueOnce("native-agents-md") // process
+      .mockResolvedValueOnce("__skip__"); // architecture
+    vi.mocked(clack.multiselect)
+      .mockResolvedValueOnce([]) // practices: none
+      .mockResolvedValueOnce(["claude-code"]); // harnesses
+    await runSetup(dir, catalog);
+
+    // Delete agent output
+    await rm(join(dir, ".claude"), { recursive: true, force: true });
+
+    // Re-install
+    await runInstall(dir, ["claude-code"]);
+
+    const agentMd = await readFile(
+      join(dir, ".claude", "agents", "ade.md"),
+      "utf-8"
+    );
+    expect(agentMd).toContain("AGENTS.md");
+  });
+});

package/src/commands/install.spec.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { LogicalConfig } from "@codemcp/ade-core";
+
+// ── Mocks ────────────────────────────────────────────────────────────────────
+
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
+}));
+
+const mockLogical: LogicalConfig = {
+  mcp_servers: [],
+  instructions: ["test instruction"],
+  cli_actions: [],
+  knowledge_sources: [],
+  skills: [],
+  git_hooks: [],
+  setup_notes: []
+};
+
+vi.mock("@codemcp/ade-core", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("@codemcp/ade-core");
+  return {
+    ...actual,
+    readLockFile: vi.fn()
+  };
+});
+
+const mockInstall = vi.fn().mockResolvedValue(undefined);
+
+vi.mock("@codemcp/ade-harnesses", () => ({
+  getHarnessWriter: vi.fn().mockImplementation((id: string) => {
+    if (id === "universal" || id === "claude-code" || id === "cursor") {
+      return { id, install: mockInstall };
+    }
+    return undefined;
+  }),
+  getHarnessIds: vi
+    .fn()
+    .mockReturnValue([
+      "universal",
+      "claude-code",
+      "cursor",
+      "copilot",
+      "windsurf",
+      "cline",
+      "roo-code",
+      "kiro",
+      "opencode"
+    ]),
+  installSkills: vi.fn().mockResolvedValue(undefined)
+}));
+
+import * as clack from "@clack/prompts";
+import { readLockFile } from "@codemcp/ade-core";
+import { runInstall } from "./install.js";
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("runInstall", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Re-set the default implementation after clearAllMocks
+    const { getHarnessWriter } = await import("@codemcp/ade-harnesses");
+    vi.mocked(getHarnessWriter).mockImplementation((id: string) => {
+      if (id === "universal" || id === "claude-code" || id === "cursor") {
+        return {
+          id,
+          label: id,
+          description: "test",
+          install: mockInstall
+        };
+      }
+      return undefined;
+    });
+  });
+
+  it("reads config.lock.yaml and applies logical config", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      logical_config: mockLogical
+    });
+
+    await runInstall("/tmp/project");
+
+    expect(readLockFile).toHaveBeenCalledWith("/tmp/project");
+  });
+
+  it("defaults to universal harness when none specified", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      logical_config: mockLogical
+    });
+
+    await runInstall("/tmp/project");
+
+    expect(mockInstall).toHaveBeenCalledWith(mockLogical, "/tmp/project");
+  });
+
+  it("uses harnesses from lock file when present", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      harnesses: ["claude-code", "cursor"],
+      logical_config: mockLogical
+    });
+
+    await runInstall("/tmp/project");
+
+    expect(mockInstall).toHaveBeenCalledTimes(2);
+  });
+
+  it("uses explicit harness ids when provided", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      harnesses: ["claude-code"],
+      logical_config: mockLogical
+    });
+
+    await runInstall("/tmp/project", ["cursor"]);
+
+    // Explicit takes priority over lock file
+    expect(mockInstall).toHaveBeenCalledTimes(1);
+  });
+
+  it("throws when config.lock.yaml is missing", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce(null);
+
+    await expect(runInstall("/tmp/project")).rejects.toThrow(
+      /config\.lock\.yaml not found/i
+    );
+  });
+
+  it("throws when harness id is unknown", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      logical_config: mockLogical
+    });
+
+    await expect(runInstall("/tmp/project", ["unknown-agent"])).rejects.toThrow(
+      /unknown harness/i
+    );
+  });
+
+  it("shows intro and outro messages", async () => {
+    vi.mocked(readLockFile).mockResolvedValueOnce({
+      version: 1,
+      generated_at: "2024-01-01T00:00:00.000Z",
+      choices: { process: "codemcp-workflows" },
+      logical_config: mockLogical
+    });
+
+    await runInstall("/tmp/project");
+
+    expect(clack.intro).toHaveBeenCalled();
+    expect(clack.outro).toHaveBeenCalled();
+  });
+});

package/src/commands/install.ts

@@ -0,0 +1,53 @@
+import * as clack from "@clack/prompts";
+import { readLockFile } from "@codemcp/ade-core";
+import {
+  getHarnessWriter,
+  getHarnessIds,
+  installSkills
+} from "@codemcp/ade-harnesses";
+
+export async function runInstall(
+  projectRoot: string,
+  harnessIds?: string[]
+): Promise<void> {
+  clack.intro("ade install");
+
+  const lockFile = await readLockFile(projectRoot);
+  if (!lockFile) {
+    throw new Error("config.lock.yaml not found. Run `ade setup` first.");
+  }
+
+  // Determine which harnesses to install for:
+  // 1. --harness flag (comma-separated)
+  // 2. harnesses saved in the lock file
+  // 3. default: universal
+  const ids = harnessIds ?? lockFile.harnesses ?? ["universal"];
+
+  const validIds = getHarnessIds();
+  for (const id of ids) {
+    if (!validIds.includes(id)) {
+      throw new Error(
+        `Unknown harness "${id}". Available: ${validIds.join(", ")}`
+      );
+    }
+  }
+
+  const logicalConfig = lockFile.logical_config;
+
+  for (const id of ids) {
+    const writer = getHarnessWriter(id);
+    if (writer) {
+      await writer.install(logicalConfig, projectRoot);
+    }
+  }
+
+  await installSkills(logicalConfig.skills, projectRoot);
+
+  if (logicalConfig.knowledge_sources.length > 0) {
+    clack.log.info(
+      "Knowledge sources configured. Initialize them separately:\n  npx @codemcp/knowledge init"
+    );
+  }
+
+  clack.outro("Install complete!");
+}