@codemcp/ade-cli 0.2.0 → 0.2.2

package/src/commands/setup.spec.ts

@@ -1,442 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Catalog, LogicalConfig } from "@codemcp/ade-core";
-
-// ── Mocks ────────────────────────────────────────────────────────────────────
-
-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(),
-  log: { warn: vi.fn(), info: vi.fn() },
-  spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
-}));
-
-vi.mock("@codemcp/ade-core", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("@codemcp/ade-core");
-  return {
-    ...actual,
-    readUserConfig: vi.fn().mockResolvedValue(null),
-    writeUserConfig: vi.fn().mockResolvedValue(undefined),
-    writeLockFile: vi.fn().mockResolvedValue(undefined),
-    resolve: vi.fn().mockResolvedValue({
-      mcp_servers: [],
-      instructions: [],
-      cli_actions: [],
-      knowledge_sources: [],
-      skills: [],
-      git_hooks: [],
-      setup_notes: []
-    } satisfies LogicalConfig),
-    collectDocsets: actual.collectDocsets
-  };
-});
-
-vi.mock("@codemcp/ade-harnesses", () => ({
-  allHarnessWriters: [
-    {
-      id: "claude-code",
-      label: "Claude Code",
-      description: "test",
-      install: vi.fn().mockResolvedValue(undefined)
-    }
-  ],
-  getHarnessWriter: vi.fn().mockReturnValue({
-    id: "claude-code",
-    label: "Claude Code",
-    description: "test",
-    install: vi.fn().mockResolvedValue(undefined)
-  }),
-  getHarnessIds: vi.fn().mockReturnValue(["claude-code"]),
-  installSkills: vi.fn().mockResolvedValue(undefined),
-  writeInlineSkills: vi.fn().mockResolvedValue([])
-}));
-
-import * as clack from "@clack/prompts";
-import {
-  readUserConfig,
-  writeUserConfig,
-  writeLockFile,
-  resolve
-} from "@codemcp/ade-core";
-import { runSetup } from "./setup.js";
-
-// ── Test catalog fixture ─────────────────────────────────────────────────────
-
-const testCatalog: Catalog = {
-  facets: [
-    {
-      id: "process",
-      label: "Process",
-      description: "How your agent works",
-      required: true,
-      options: [
-        {
-          id: "workflow-a",
-          label: "Workflow A",
-          description: "First workflow option",
-          recipe: []
-        },
-        {
-          id: "workflow-b",
-          label: "Workflow B",
-          description: "Second workflow option",
-          recipe: []
-        }
-      ]
-    },
-    {
-      id: "testing",
-      label: "Testing",
-      description: "Testing strategy",
-      required: false,
-      options: [
-        {
-          id: "vitest",
-          label: "Vitest",
-          description: "Use vitest",
-          recipe: []
-        },
-        {
-          id: "jest",
-          label: "Jest",
-          description: "Use jest",
-          recipe: []
-        }
-      ]
-    }
-  ]
-};
-
-const docsetCatalog: Catalog = {
-  facets: [
-    {
-      id: "arch",
-      label: "Architecture",
-      description: "Stack",
-      required: true,
-      options: [
-        {
-          id: "react",
-          label: "React",
-          description: "React framework",
-          recipe: [],
-          docsets: [
-            {
-              id: "react-docs",
-              label: "React Reference",
-              origin: "https://github.com/facebook/react.git",
-              description: "Official React docs"
-            },
-            {
-              id: "react-tutorial",
-              label: "React Tutorial",
-              origin: "https://github.com/reactjs/react.dev.git",
-              description: "React learn guide"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-};
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-describe("runSetup", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("prompts for each catalog facet and writes user config", async () => {
-    // User selects "workflow-a" for process, "vitest" for testing
-    vi.mocked(clack.select)
-      .mockResolvedValueOnce("workflow-a")
-      .mockResolvedValueOnce("vitest");
-    // Harness multiselect
-    vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    // select() called once per facet
-    expect(clack.select).toHaveBeenCalledTimes(2);
-
-    // writeUserConfig called with collected choices
-    expect(writeUserConfig).toHaveBeenCalledWith(
-      "/tmp/test-project",
-      expect.objectContaining({
-        choices: { process: "workflow-a", testing: "vitest" }
-      })
-    );
-  });
-
-  it("resolves the config and writes the lock file", async () => {
-    const mockLogical: LogicalConfig = {
-      mcp_servers: [],
-      instructions: ["do stuff"],
-      cli_actions: [],
-      knowledge_sources: [],
-      skills: [],
-      git_hooks: [],
-      setup_notes: []
-    };
-    vi.mocked(resolve).mockResolvedValueOnce(mockLogical);
-    vi.mocked(clack.select)
-      .mockResolvedValueOnce("workflow-a")
-      .mockResolvedValueOnce("vitest");
-    vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    // resolve() called with the user config, catalog, and a registry
-    expect(resolve).toHaveBeenCalledOnce();
-    const resolveArgs = vi.mocked(resolve).mock.calls[0];
-    expect(resolveArgs[0]).toMatchObject({
-      choices: { process: "workflow-a", testing: "vitest" }
-    });
-
-    // writeLockFile called with the resolved logical config
-    expect(writeLockFile).toHaveBeenCalledWith(
-      "/tmp/test-project",
-      expect.objectContaining({
-        version: 1,
-        logical_config: mockLogical
-      })
-    );
-  });
-
-  it("excludes skipped facets from choices", async () => {
-    // User selects workflow-a for process, skips testing (returns null sentinel)
-    vi.mocked(clack.select)
-      .mockResolvedValueOnce("workflow-a")
-      .mockResolvedValueOnce("__skip__");
-    vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    expect(writeUserConfig).toHaveBeenCalledWith(
-      "/tmp/test-project",
-      expect.objectContaining({
-        choices: { process: "workflow-a" }
-      })
-    );
-  });
-
-  it("aborts without writing files when user cancels", async () => {
-    // First select returns a cancel symbol
-    const cancelSymbol = Symbol("cancel");
-    vi.mocked(clack.select).mockResolvedValueOnce(cancelSymbol);
-    vi.mocked(clack.isCancel).mockReturnValue(true);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    expect(writeUserConfig).not.toHaveBeenCalled();
-    expect(writeLockFile).not.toHaveBeenCalled();
-    expect(clack.cancel).toHaveBeenCalled();
-  });
-
-  describe("docset confirmation step", () => {
-    it("presents implied docsets as a multiselect after facet selection", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      // User accepts all docsets (returns all ids), then harness selection
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs", "react-tutorial"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      // multiselect should have been called for docsets
-      expect(clack.multiselect).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: expect.stringContaining("Documentation")
-        })
-      );
-    });
-
-    it("stores deselected docsets as excluded_docsets in user config", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      // User deselects react-tutorial, keeps only react-docs; then harness
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      expect(writeUserConfig).toHaveBeenCalledWith(
-        "/tmp/test-project",
-        expect.objectContaining({
-          excluded_docsets: ["react-tutorial"]
-        })
-      );
-    });
-
-    it("does not set excluded_docsets when all docsets are accepted", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs", "react-tutorial"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      const configArg = vi.mocked(writeUserConfig).mock.calls[0][1];
-      expect(configArg.excluded_docsets).toBeUndefined();
-    });
-
-    it("skips docset prompt when no options have docsets", async () => {
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("workflow-a")
-        .mockResolvedValueOnce("vitest");
-      // Only the harness multiselect should be called (no docsets in testCatalog)
-      vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", testCatalog);
-
-      // multiselect should have been called exactly once (for harnesses only)
-      expect(clack.multiselect).toHaveBeenCalledTimes(1);
-      expect(clack.multiselect).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: expect.stringContaining("Harnesses")
-        })
-      );
-    });
-  });
-
-  it("calls intro and outro from @clack/prompts", async () => {
-    vi.mocked(clack.select)
-      .mockResolvedValueOnce("workflow-a")
-      .mockResolvedValueOnce("vitest");
-    vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    expect(clack.intro).toHaveBeenCalled();
-    expect(clack.outro).toHaveBeenCalled();
-  });
-
-  it("displays each setup note via clack.log.info", async () => {
-    const mockLogical: LogicalConfig = {
-      mcp_servers: [],
-      instructions: [],
-      cli_actions: [],
-      knowledge_sources: [],
-      skills: [],
-      git_hooks: [],
-      setup_notes: ["Add lint script to package.json", "Run npm install"]
-    };
-    vi.mocked(resolve).mockResolvedValueOnce(mockLogical);
-    vi.mocked(clack.select)
-      .mockResolvedValueOnce("workflow-a")
-      .mockResolvedValueOnce("vitest");
-    vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-    await runSetup("/tmp/test-project", testCatalog);
-
-    expect(clack.log.info).toHaveBeenCalledWith(
-      "Add lint script to package.json"
-    );
-    expect(clack.log.info).toHaveBeenCalledWith("Run npm install");
-  });
-
-  describe("re-run with existing config", () => {
-    it("passes existing single-select choice as initialValue", async () => {
-      vi.mocked(readUserConfig).mockResolvedValueOnce({
-        choices: { process: "workflow-b", testing: "jest" }
-      });
-
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("workflow-b")
-        .mockResolvedValueOnce("jest");
-      vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", testCatalog);
-
-      // First select (process) should receive initialValue "workflow-b"
-      expect(clack.select).toHaveBeenCalledWith(
-        expect.objectContaining({ initialValue: "workflow-b" })
-      );
-      // Second select (testing) should receive initialValue "jest"
-      expect(clack.select).toHaveBeenCalledWith(
-        expect.objectContaining({ initialValue: "jest" })
-      );
-    });
-
-    it("passes existing multi-select choices as initialValues", async () => {
-      const multiCatalog: Catalog = {
-        facets: [
-          {
-            id: "practices",
-            label: "Practices",
-            description: "Dev practices",
-            required: false,
-            multiSelect: true,
-            options: [
-              {
-                id: "tdd",
-                label: "TDD",
-                description: "Test-driven dev",
-                recipe: []
-              },
-              {
-                id: "adr",
-                label: "ADR",
-                description: "Architecture decisions",
-                recipe: []
-              }
-            ]
-          }
-        ]
-      };
-
-      vi.mocked(readUserConfig).mockResolvedValueOnce({
-        choices: { practices: ["tdd", "adr"] }
-      });
-
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["tdd", "adr"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", multiCatalog);
-
-      expect(clack.multiselect).toHaveBeenCalledWith(
-        expect.objectContaining({ initialValues: ["tdd", "adr"] })
-      );
-    });
-
-    it("warns when existing choice references a stale option", async () => {
-      vi.mocked(readUserConfig).mockResolvedValueOnce({
-        choices: { process: "workflow-a", testing: "mocha" } // "mocha" doesn't exist
-      });
-
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("workflow-a")
-        .mockResolvedValueOnce("vitest");
-      vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", testCatalog);
-
-      expect(clack.log.warn).toHaveBeenCalledWith(
-        expect.stringContaining("mocha")
-      );
-    });
-
-    it("does not set initialValue for stale option", async () => {
-      vi.mocked(readUserConfig).mockResolvedValueOnce({
-        choices: { process: "deleted-option" }
-      });
-
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("workflow-a")
-        .mockResolvedValueOnce("vitest");
-      vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", testCatalog);
-
-      // First select (process) should NOT have initialValue set
-      const firstCall = vi.mocked(clack.select).mock.calls[0][0];
-      expect(firstCall).not.toHaveProperty("initialValue");
-    });
-  });
-});

package/src/commands/setup.ts

@@ -1,252 +0,0 @@
-import * as clack from "@clack/prompts";
-import {
-  type Catalog,
-  type Facet,
-  type UserConfig,
-  type LockFile,
-  readUserConfig,
-  writeUserConfig,
-  writeLockFile,
-  resolve,
-  collectDocsets,
-  createDefaultRegistry,
-  getFacet,
-  getOption,
-  sortFacets,
-  getVisibleOptions
-} from "@codemcp/ade-core";
-import {
-  allHarnessWriters,
-  getHarnessWriter,
-  installSkills,
-  writeInlineSkills
-} from "@codemcp/ade-harnesses";
-
-export async function runSetup(
-  projectRoot: string,
-  catalog: Catalog
-): Promise<void> {
-  clack.intro("ade setup");
-
-  const existingConfig = await readUserConfig(projectRoot);
-  const existingChoices = existingConfig?.choices ?? {};
-
-  // Warn about stale choices that reference options no longer in the catalog
-  for (const [facetId, value] of Object.entries(existingChoices)) {
-    const facet = getFacet(catalog, facetId);
-    if (!facet) continue;
-
-    const ids = Array.isArray(value) ? value : [value];
-    for (const optionId of ids) {
-      if (!getOption(facet, optionId)) {
-        clack.log.warn(
-          `Previously selected option "${optionId}" is no longer available in facet "${facet.label}".`
-        );
-      }
-    }
-  }
-
-  const choices: Record<string, string | string[]> = {};
-
-  const sortedFacets = sortFacets(catalog);
-
-  for (const facet of sortedFacets) {
-    const visibleOptions = getVisibleOptions(facet, choices, catalog);
-    if (visibleOptions.length === 0) continue;
-
-    const visibleFacet = { ...facet, options: visibleOptions };
-
-    if (facet.multiSelect) {
-      const selected = await promptMultiSelect(visibleFacet, existingChoices);
-      if (typeof selected === "symbol") {
-        clack.cancel("Setup cancelled.");
-        return;
-      }
-      if (selected.length > 0) {
-        choices[facet.id] = selected;
-      }
-    } else {
-      const selected = await promptSelect(visibleFacet, existingChoices);
-      if (typeof selected === "symbol") {
-        clack.cancel("Setup cancelled.");
-        return;
-      }
-      if (typeof selected === "string" && selected !== "__skip__") {
-        choices[facet.id] = selected;
-      }
-    }
-  }
-
-  // Docset confirmation step: collect implied docsets, let user deselect
-  const impliedDocsets = collectDocsets(choices, catalog);
-  let excludedDocsets: string[] | undefined;
-
-  if (impliedDocsets.length > 0) {
-    const selected = await clack.multiselect({
-      message: "Documentation — deselect any you don't need",
-      options: impliedDocsets.map((d) => ({
-        value: d.id,
-        label: d.label,
-        hint: d.description
-      })),
-      initialValues: impliedDocsets.map((d) => d.id),
-      required: false
-    });
-
-    if (typeof selected === "symbol") {
-      clack.cancel("Setup cancelled.");
-      return;
-    }
-
-    const selectedSet = new Set(selected as string[]);
-    const excluded = impliedDocsets
-      .filter((d) => !selectedSet.has(d.id))
-      .map((d) => d.id);
-    if (excluded.length > 0) {
-      excludedDocsets = excluded;
-    }
-  }
-
-  // Harness selection — multi-select from all available harnesses
-  const existingHarnesses = existingConfig?.harnesses;
-  const harnessOptions = allHarnessWriters.map((w) => ({
-    value: w.id,
-    label: w.label,
-    hint: w.description
-  }));
-
-  const validExistingHarnesses = existingHarnesses?.filter((h) =>
-    allHarnessWriters.some((w) => w.id === h)
-  );
-
-  const selectedHarnesses = await clack.multiselect({
-    message: "Harnesses — which coding agents should receive config?",
-    options: harnessOptions,
-    initialValues:
-      validExistingHarnesses && validExistingHarnesses.length > 0
-        ? validExistingHarnesses
-        : ["universal"],
-    required: false
-  });
-
-  if (typeof selectedHarnesses === "symbol") {
-    clack.cancel("Setup cancelled.");
-    return;
-  }
-
-  const harnesses = selectedHarnesses as string[];
-
-  const userConfig: UserConfig = {
-    choices,
-    ...(excludedDocsets && { excluded_docsets: excludedDocsets }),
-    ...(harnesses.length > 0 && { harnesses })
-  };
-  const registry = createDefaultRegistry();
-  const logicalConfig = await resolve(userConfig, catalog, registry);
-
-  await writeUserConfig(projectRoot, userConfig);
-
-  const lockFile: LockFile = {
-    version: 1,
-    generated_at: new Date().toISOString(),
-    choices: userConfig.choices,
-    ...(harnesses.length > 0 && { harnesses }),
-    logical_config: logicalConfig
-  };
-  await writeLockFile(projectRoot, lockFile);
-
-  // Install to all selected harnesses
-  for (const harnessId of harnesses) {
-    const writer = getHarnessWriter(harnessId);
-    if (writer) {
-      await writer.install(logicalConfig, projectRoot);
-    }
-  }
-
-  const modifiedSkills = await writeInlineSkills(logicalConfig, projectRoot);
-  if (modifiedSkills.length > 0) {
-    clack.log.warn(
-      `The following skills have been locally modified and will NOT be updated:\n` +
-        modifiedSkills.map((s) => `  - ${s}`).join("\n") +
-        `\n\nTo use the latest defaults, remove .ade/skills/ and re-run setup.`
-    );
-  }
-
-  await installSkills(logicalConfig.skills, projectRoot);
-
-  if (logicalConfig.knowledge_sources.length > 0) {
-    clack.log.info(
-      "Knowledge sources selected. Initialize them separately:\n  npx @codemcp/knowledge init"
-    );
-  }
-
-  for (const note of logicalConfig.setup_notes) {
-    clack.log.info(note);
-  }
-
-  clack.outro("Setup complete!");
-}
-
-function getValidInitialValue(
-  facet: Facet,
-  existingChoices: Record<string, string | string[]>
-): string | undefined {
-  const value = existingChoices[facet.id];
-  if (typeof value !== "string") return undefined;
-  // Only set initialValue if the option still exists in the catalog
-  return facet.options.some((o) => o.id === value) ? value : undefined;
-}
-
-function getValidInitialValues(
-  facet: Facet,
-  existingChoices: Record<string, string | string[]>
-): string[] | undefined {
-  const value = existingChoices[facet.id];
-  if (!Array.isArray(value)) return undefined;
-  // Only include options that still exist in the catalog
-  const valid = value.filter((v) => facet.options.some((o) => o.id === v));
-  return valid.length > 0 ? valid : undefined;
-}
-
-function promptSelect(
-  facet: Facet,
-  existingChoices: Record<string, string | string[]>
-) {
-  const options = facet.options.map((o) => ({
-    value: o.id,
-    label: o.label,
-    hint: o.description
-  }));
-
-  if (!facet.required) {
-    options.push({ value: "__skip__", label: "Skip", hint: "" });
-  }
-
-  const initialValue = getValidInitialValue(facet, existingChoices);
-
-  return clack.select({
-    message: facet.label,
-    options,
-    ...(initialValue !== undefined && { initialValue })
-  });
-}
-
-function promptMultiSelect(
-  facet: Facet,
-  existingChoices: Record<string, string | string[]>
-) {
-  const options = facet.options.map((o) => ({
-    value: o.id,
-    label: o.label,
-    hint: o.description
-  }));
-
-  const initialValues = getValidInitialValues(facet, existingChoices);
-
-  return clack.multiselect({
-    message: facet.label,
-    options,
-    required: false,
-    ...(initialValues !== undefined && { initialValues })
-  });
-}