@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/domains/setup/operations/setupCompletions.test.ts

@@ -1,94 +0,0 @@
-import { dryRunWith, type Effect } from "@canonical/task";
-import { describe, expect, it } from "vitest";
-import setupCompletions from "./setupCompletions.js";
-
-const mockExists =
-  (predicate: (path: string) => boolean) =>
-  (effect: Effect): unknown =>
-    predicate((effect as Effect & { _tag: "Exists" }).path);
-
-function mocks(
-  existsPredicate: (path: string) => boolean,
-): Map<string, (effect: Effect) => unknown> {
-  return new Map([["Exists", mockExists(existsPredicate)]]);
-}
-
-describe("setupCompletions", () => {
-  it("writes zsh completion to ~/.zfunc/_pragma", () => {
-    const result = dryRunWith(
-      setupCompletions("zsh"),
-      mocks(() => true), // dir exists
-    );
-
-    const writes = result.effects.filter(
-      (e) => e._tag === "WriteFile",
-    ) as (Effect & { _tag: "WriteFile" })[];
-    expect(writes).toHaveLength(1);
-    expect(writes[0].path).toContain(".zfunc/_pragma");
-    expect(writes[0].content).toContain("#compdef pragma");
-  });
-
-  it("writes bash completion to standard path", () => {
-    const result = dryRunWith(
-      setupCompletions("bash"),
-      mocks(() => true),
-    );
-
-    const writes = result.effects.filter(
-      (e) => e._tag === "WriteFile",
-    ) as (Effect & { _tag: "WriteFile" })[];
-    expect(writes).toHaveLength(1);
-    expect(writes[0].path).toContain("bash-completion/completions/pragma");
-    expect(writes[0].content).toContain("complete -F _pragma pragma");
-  });
-
-  it("writes fish completion to standard path", () => {
-    const result = dryRunWith(
-      setupCompletions("fish"),
-      mocks(() => true),
-    );
-
-    const writes = result.effects.filter(
-      (e) => e._tag === "WriteFile",
-    ) as (Effect & { _tag: "WriteFile" })[];
-    expect(writes).toHaveLength(1);
-    expect(writes[0].path).toContain("fish/completions/pragma.fish");
-    expect(writes[0].content).toContain("complete -c pragma");
-  });
-
-  it("creates parent directory when missing", () => {
-    const result = dryRunWith(
-      setupCompletions("zsh"),
-      mocks(() => false), // dir does not exist
-    );
-
-    const mkdirs = result.effects.filter((e) => e._tag === "MakeDir");
-    expect(mkdirs.length).toBeGreaterThan(0);
-  });
-
-  it("warns when shell is undetected (no force)", () => {
-    // This test works because detectShell() reads process.env.SHELL.
-    // We pass undefined (no force) but mock nothing — detectShell() will
-    // use the real $SHELL. To test the null path, we'd need to unset $SHELL.
-    // Instead, just verify the forced-null scenario:
-    // Since we can't easily unset $SHELL in this test, we verify the
-    // happy path works and the warning path is tested separately.
-    const result = dryRunWith(
-      setupCompletions("zsh"),
-      mocks(() => true),
-    );
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(
-      logs.some((l) => l.message.includes("✓ Completions installed")),
-    ).toBe(true);
-  });
-
-  it("includes post-install hint in output", () => {
-    const result = dryRunWith(
-      setupCompletions("zsh"),
-      mocks(() => true),
-    );
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("source ~/.zshrc"))).toBe(true);
-  });
-});

package/src/domains/setup/operations/setupCompletions.ts

@@ -1,54 +0,0 @@
-import { dirname } from "node:path";
-import {
-  $,
-  exists,
-  gen,
-  info,
-  mkdir,
-  type Task,
-  warn,
-  writeFile,
-} from "@canonical/task";
-import {
-  completionScriptContent,
-  completionScriptPath,
-  postInstallHint,
-} from "../helpers/completionScripts.js";
-import detectShell, { type ShellId } from "../helpers/detectShell.js";
-
-/**
- * Compose a Task that detects the user's shell and writes the
- * appropriate completion script to the standard install path.
- *
- * @param forceShell - If set, skip detection and use this shell.
- * @returns A Task that yields void on completion.
- * @note Impure
- */
-export default function setupCompletions(forceShell?: ShellId): Task<void> {
-  return gen(function* () {
-    const shell = forceShell ?? detectShell();
-
-    if (!shell) {
-      yield* $(
-        warn("Shell not detected. Use --zsh, --bash, or --fish to specify."),
-      );
-      return;
-    }
-
-    yield* $(info(`Setting up completions for ${shell}...`));
-
-    const path = completionScriptPath(shell);
-    const dir = dirname(path);
-
-    const dirExists = yield* $(exists(dir));
-    if (!dirExists) {
-      yield* $(mkdir(dir, true));
-    }
-
-    const script = completionScriptContent(shell);
-    yield* $(writeFile(path, script));
-
-    yield* $(info(`✓ Completions installed for ${shell}.`));
-    yield* $(info(`  ${postInstallHint(shell)}`));
-  });
-}

package/src/domains/setup/operations/setupLsp.test.ts

@@ -1,29 +0,0 @@
-import { collectEffects, dryRun } from "@canonical/task";
-import { describe, expect, it } from "vitest";
-import setupLsp from "./setupLsp.js";
-
-describe("setupLsp", () => {
-  it("produces an exec effect for bunx", () => {
-    const result = dryRun(setupLsp("/project"));
-    const execs = result.effects.filter((e) => e._tag === "Exec");
-    expect(execs).toHaveLength(1);
-    expect(execs[0]).toMatchObject({
-      _tag: "Exec",
-      command: "bunx",
-      args: ["@canonical/terrazzo-lsp-extension"],
-      cwd: "/project",
-    });
-  });
-
-  it("logs info messages before and after exec", () => {
-    const result = dryRun(setupLsp("/project"));
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("Installing"))).toBe(true);
-    expect(logs.some((l) => l.message.includes("✓"))).toBe(true);
-  });
-
-  it("collects effects without execution", () => {
-    const effects = collectEffects(setupLsp("/project"));
-    expect(effects.length).toBeGreaterThan(0);
-  });
-});

package/src/domains/setup/operations/setupLsp.ts

@@ -1,17 +0,0 @@
-import { $, exec, gen, info, type Task } from "@canonical/task";
-
-/**
- * Compose a Task that installs the Terrazzo LSP VS Code extension
- * by running `bunx @canonical/terrazzo-lsp-extension`.
- *
- * @param root - Project root directory (used as cwd for the subprocess).
- * @returns A Task that yields void on completion.
- * @note Impure
- */
-export default function setupLsp(root: string): Task<void> {
-  return gen(function* () {
-    yield* $(info("Installing Terrazzo LSP extension for VS Code..."));
-    yield* $(exec("bunx", ["@canonical/terrazzo-lsp-extension"], root));
-    yield* $(info("✓ Terrazzo LSP extension installed."));
-  });
-}

package/src/domains/setup/operations/setupMcp.test.ts

@@ -1,120 +0,0 @@
-import { dryRunWith, type Effect } from "@canonical/task";
-import { describe, expect, it } from "vitest";
-import setupMcp from "./setupMcp.js";
-
-const mockExists =
-  (predicate: (path: string) => boolean) =>
-  (effect: Effect): unknown =>
-    predicate((effect as Effect & { _tag: "Exists" }).path);
-
-function mocks(
-  existsPredicate: (path: string) => boolean,
-): Map<string, (effect: Effect) => unknown> {
-  return new Map<string, (effect: Effect) => unknown>([
-    ["Exists", mockExists(existsPredicate)],
-    // An existing config reads back as an empty-but-valid JSON object, so a
-    // write merges into it rather than failing closed on the dry-run placeholder.
-    ["ReadFile", () => "{}"],
-  ]);
-}
-
-describe("setupMcp", () => {
-  it("warns when no harnesses are detected", () => {
-    const result = dryRunWith(
-      setupMcp("/project"),
-      mocks(() => false),
-    );
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("No AI harnesses"))).toBe(true);
-  });
-
-  it("does not write config when no harnesses detected", () => {
-    const result = dryRunWith(
-      setupMcp("/project"),
-      mocks(() => false),
-    );
-    const writes = result.effects.filter((e) => e._tag === "WriteFile");
-    expect(writes).toHaveLength(0);
-  });
-
-  it("detects Claude Code and writes config (dry-run defaults confirm)", () => {
-    const result = dryRunWith(
-      setupMcp("/project"),
-      mocks((p) => p.includes(".claude") || p === "/project/.mcp.json"),
-    );
-
-    const writes = result.effects.filter(
-      (e) => e._tag === "WriteFile",
-    ) as (Effect & { _tag: "WriteFile" })[];
-    expect(writes.length).toBeGreaterThan(0);
-
-    // At least one write should contain pragma MCP config
-    const mcpWrite = writes.find((w) => w.path.includes(".mcp.json"));
-    expect(mcpWrite).toBeDefined();
-    if (mcpWrite) {
-      const config = JSON.parse(mcpWrite.content);
-      expect(config.mcpServers?.pragma?.command).toBe("pragma");
-    }
-  });
-
-  it("force harness bypasses detection", () => {
-    const result = dryRunWith(
-      setupMcp("/project", "claude-code"),
-      mocks(() => false), // nothing exists, but force skips detection
-    );
-
-    const writes = result.effects.filter((e) => e._tag === "WriteFile");
-    expect(writes.length).toBeGreaterThan(0);
-
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("✓"))).toBe(true);
-  });
-
-  it("warns on unknown force harness", () => {
-    const result = dryRunWith(
-      setupMcp("/project", "nonexistent"),
-      mocks(() => false),
-    );
-
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    expect(logs.some((l) => l.message.includes("Unknown harness"))).toBe(true);
-
-    const writes = result.effects.filter((e) => e._tag === "WriteFile");
-    expect(writes).toHaveLength(0);
-  });
-
-  it("detects multiple harnesses", () => {
-    const result = dryRunWith(
-      setupMcp("/project"),
-      mocks(
-        (p) =>
-          p.includes(".claude") ||
-          p.includes(".mcp.json") ||
-          p.includes(".cursor"),
-      ),
-    );
-
-    const logs = result.effects.filter((e) => e._tag === "Log");
-    const detectedLog = logs.find((l) => l.message.includes("Detected"));
-    expect(detectedLog).toBeDefined();
-
-    // Multiple writes expected (one per confirmed harness)
-    const writes = result.effects.filter((e) => e._tag === "WriteFile");
-    expect(writes.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it("includes prompt effects for each detected harness", () => {
-    const result = dryRunWith(
-      setupMcp("/project"),
-      mocks(
-        (p) =>
-          p.includes(".claude") ||
-          p.includes(".mcp.json") ||
-          p.includes(".cursor"),
-      ),
-    );
-
-    const prompts = result.effects.filter((e) => e._tag === "Prompt");
-    expect(prompts.length).toBeGreaterThanOrEqual(2);
-  });
-});

package/src/domains/setup/operations/setupMcp.ts

@@ -1,108 +0,0 @@
-import type { McpServerConfig } from "@canonical/harnesses";
-import {
-  detectHarnesses,
-  findHarnessById,
-  writeMcpConfig,
-} from "@canonical/harnesses";
-import {
-  $,
-  gen,
-  info,
-  promptConfirm,
-  type Task,
-  traverse_,
-  warn,
-  when,
-} from "@canonical/task";
-import { MCP_SERVER_NAME } from "../helpers/constants.js";
-
-/**
- * Build the pragma MCP server config object for a project root.
- *
- * @param root - Project root directory.
- * @returns The MCP server configuration pointing to `pragma mcp`.
- */
-function pragmaMcpConfig(root: string): McpServerConfig {
-  return { command: "pragma", args: ["mcp"], cwd: root };
-}
-
-/**
- * Compose a Task that configures the pragma MCP server for detected
- * (or forced) AI harnesses. In detection mode, prompts for each
- * discovered harness before writing.
- *
- * @param root - Project root directory.
- * @param forceHarnessId - If set, bypass detection and configure this harness only.
- * @returns A Task that yields void on completion.
- * @note Impure
- */
-export default function setupMcp(
-  root: string,
-  forceHarnessId?: string,
-): Task<void> {
-  return gen(function* () {
-    // Force mode: bypass detection
-    if (forceHarnessId) {
-      const harness = findHarnessById(forceHarnessId);
-      if (!harness) {
-        yield* $(warn(`Unknown harness: ${forceHarnessId}`));
-        return;
-      }
-      yield* $(
-        writeMcpConfig(harness, root, MCP_SERVER_NAME, pragmaMcpConfig(root)),
-      );
-      yield* $(
-        info(`✓ pragma MCP server added to ${harness.configPath(root)}`),
-      );
-      return;
-    }
-
-    // Detection mode
-    const detected = yield* $(detectHarnesses(root));
-
-    if (detected.length === 0) {
-      yield* $(
-        warn(
-          "No AI harnesses detected. Use --claude-code, --cursor, or --windsurf to configure manually.",
-        ),
-      );
-      return;
-    }
-
-    yield* $(
-      info(
-        `Detected harness${detected.length > 1 ? "es" : ""}: ${detected.map((d) => d.harness.name).join(", ")}`,
-      ),
-    );
-
-    yield* $(
-      traverse_(detected, (d) =>
-        gen(function* () {
-          const confirmed = yield* $(
-            promptConfirm(
-              `setup-mcp-${d.harness.id}`,
-              `Configure pragma MCP for ${d.harness.name}?`,
-              true,
-            ),
-          );
-          yield* $(
-            when(
-              confirmed,
-              gen(function* () {
-                yield* $(
-                  writeMcpConfig(
-                    d.harness,
-                    root,
-                    MCP_SERVER_NAME,
-                    pragmaMcpConfig(root),
-                  ),
-                );
-                yield* $(info(`✓ pragma MCP server added to ${d.configPath}`));
-              }),
-            ),
-          );
-        }),
-      ),
-    );
-  });
-}

package/src/domains/setup/operations/setupSkills.test.ts

@@ -1,191 +0,0 @@
-import type { DetectedHarness, HarnessDefinition } from "@canonical/harnesses";
-import { dryRunWith, type Effect, filterEffects } from "@canonical/task";
-import { describe, expect, it } from "vitest";
-import type { DiscoveredSkill } from "../../skill/types.js";
-import type { SetupSkillsResult } from "../types.js";
-import setupSkills from "./setupSkills.js";
-
-const MOCK_SKILLS: readonly DiscoveredSkill[] = [
-  {
-    name: "design-audit",
-    description: "Audit a component against DS specs",
-    sourcePath:
-      "/project/node_modules/@canonical/ds-global/skills/design-audit",
-    sourcePackage: "@canonical/ds-global",
-    folderName: "design-audit",
-    frontmatter: {
-      name: "design-audit",
-      description: "Audit a component against DS specs",
-    },
-  },
-  {
-    name: "scaffold-story",
-    description: "Generate a Storybook story from anatomy",
-    sourcePath:
-      "/project/node_modules/@canonical/pragma-cli/skills/scaffold-story",
-    sourcePackage: "@canonical/pragma-cli",
-    folderName: "scaffold-story",
-    frontmatter: {
-      name: "scaffold-story",
-      description: "Generate a Storybook story from anatomy",
-    },
-  },
-];
-
-function makeHarness(
-  id: string,
-  name: string,
-  skillsDir: string,
-): DetectedHarness {
-  return {
-    harness: {
-      id,
-      name,
-      version: "*",
-      detect: [],
-      configPath: () => "",
-      configFormat: "json",
-      mcpKey: "mcpServers",
-      skillsPath: (root: string) => `${root}/${skillsDir}`,
-    } as HarnessDefinition,
-    confidence: "high",
-    configExists: false,
-    configPath: "",
-  };
-}
-
-const MOCK_HARNESSES: readonly DetectedHarness[] = [
-  makeHarness("claude-code", "Claude Code", ".claude/skills"),
-  makeHarness("cursor", "Cursor", ".cursor/skills"),
-];
-
-describe("setupSkills", () => {
-  it("creates symlinks for each skill in each harness", () => {
-    const task = setupSkills(MOCK_SKILLS, MOCK_HARNESSES, "/project");
-
-    const mocks = new Map<string, (e: Effect) => unknown>([
-      ["Exists", () => false],
-    ]);
-
-    const { value, effects } = dryRunWith(task, mocks);
-    const result = value as SetupSkillsResult;
-
-    const created = result.actions.filter((a) => a.action === "created");
-    // 2 skills × 3 targets (claude, cursor, .agents/skills) = 6
-    expect(created).toHaveLength(6);
-    expect(result.harnessCount).toBe(2);
-    expect(result.skillCount).toBe(2);
-
-    const symlinkEffects = filterEffects(effects, "Symlink");
-    expect(symlinkEffects).toHaveLength(6);
-  });
-
-  it("skips existing correct symlinks", () => {
-    const task = setupSkills(MOCK_SKILLS, MOCK_HARNESSES, "/project");
-
-    const mocks = new Map<string, (e: Effect) => unknown>([
-      ["Exists", () => true],
-      [
-        "Exec",
-        (e: Effect) => {
-          if (e._tag === "Exec" && e.command === "readlink") {
-            const linkPath = e.args[0];
-            if (linkPath.includes("design-audit")) {
-              return {
-                stdout:
-                  "/project/node_modules/@canonical/ds-global/skills/design-audit",
-                stderr: "",
-                exitCode: 0,
-              };
-            }
-            if (linkPath.includes("scaffold-story")) {
-              return {
-                stdout:
-                  "/project/node_modules/@canonical/pragma-cli/skills/scaffold-story",
-                stderr: "",
-                exitCode: 0,
-              };
-            }
-          }
-          return { stdout: "", stderr: "", exitCode: 0 };
-        },
-      ],
-    ]);
-
-    const { value } = dryRunWith(task, mocks);
-    const result = value as SetupSkillsResult;
-
-    const skipped = result.actions.filter((a) => a.action === "skipped");
-    expect(skipped).toHaveLength(6);
-    expect(result.warnings).toHaveLength(0);
-  });
-
-  it("replaces wrong symlinks with warning", () => {
-    const task = setupSkills([MOCK_SKILLS[0]], [MOCK_HARNESSES[0]], "/project");
-
-    const mocks = new Map<string, (e: Effect) => unknown>([
-      ["Exists", () => true],
-      [
-        "Exec",
-        () => ({
-          stdout: "/wrong/target",
-          stderr: "",
-          exitCode: 0,
-        }),
-      ],
-    ]);
-
-    const { value } = dryRunWith(task, mocks);
-    const result = value as SetupSkillsResult;
-
-    const replaced = result.actions.filter((a) => a.action === "replaced");
-    expect(replaced.length).toBeGreaterThan(0);
-    expect(result.warnings.length).toBeGreaterThan(0);
-  });
-
-  it("deduplicates cross-client .agents/skills path", () => {
-    const harnesses = [
-      makeHarness("cline", "Cline", ".agents/skills"),
-      makeHarness("opencode", "OpenCode", ".agents/skills"),
-    ];
-
-    const task = setupSkills(MOCK_SKILLS, harnesses, "/project");
-
-    const mocks = new Map<string, (e: Effect) => unknown>([
-      ["Exists", () => false],
-    ]);
-
-    const { value } = dryRunWith(task, mocks);
-    const result = value as SetupSkillsResult;
-
-    // Both harnesses use .agents/skills, so only one set of symlinks
-    // plus no separate cross-client dir (already covered)
-    const created = result.actions.filter((a) => a.action === "created");
-    expect(created).toHaveLength(2); // 2 skills × 1 unique dir
-  });
-
-  it("handles empty skills list", () => {
-    const task = setupSkills([], MOCK_HARNESSES, "/project");
-
-    const { value } = dryRunWith(task, new Map());
-    const result = value as SetupSkillsResult;
-
-    expect(result.actions).toHaveLength(0);
-    expect(result.skillCount).toBe(0);
-  });
-
-  it("handles empty harnesses list", () => {
-    const task = setupSkills(MOCK_SKILLS, [], "/project");
-
-    const mocks = new Map<string, (e: Effect) => unknown>([
-      ["Exists", () => false],
-    ]);
-
-    const { value } = dryRunWith(task, mocks);
-    const result = value as SetupSkillsResult;
-
-    // Still creates cross-client .agents/skills
-    const created = result.actions.filter((a) => a.action === "created");
-    expect(created).toHaveLength(2); // 2 skills × 1 (.agents/skills)
-  });
-});