@canonical/pragma-cli 0.31.0 → 0.33.0

package/src/domains/refs/operations/updateRefs.test.ts

@@ -1,167 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import updateRefs from "./updateRefs.js";
-
-describe("updateRefs", () => {
-  let tmpDir: string;
-  let projectDir: string;
-  let bareRepo: string;
-  const origEnv = { ...process.env };
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "pragma-update-refs-"));
-    projectDir = join(tmpDir, "project");
-    mkdirSync(projectDir, { recursive: true });
-
-    // Point cache to temp dir
-    process.env.PRAGMA_CACHE_DIR = join(tmpDir, "cache");
-    // No global refs
-    process.env.XDG_CONFIG_HOME = join(tmpDir, "no-global-config");
-
-    // Create a bare git repo for testing
-    bareRepo = join(tmpDir, "origin.git");
-    execFileSync("git", ["init", "--bare", "-b", "main", bareRepo], {
-      stdio: "pipe",
-    });
-
-    const workDir = join(tmpDir, "work");
-    execFileSync("git", ["clone", bareRepo, workDir], { stdio: "pipe" });
-    execFileSync("git", ["-C", workDir, "config", "user.email", "t@t.com"], {
-      stdio: "pipe",
-    });
-    execFileSync("git", ["-C", workDir, "config", "user.name", "T"], {
-      stdio: "pipe",
-    });
-    execFileSync(
-      "git",
-      ["-C", workDir, "commit", "--allow-empty", "-m", "init"],
-      { stdio: "pipe" },
-    );
-    execFileSync("git", ["-C", workDir, "push", "origin", "main"], {
-      stdio: "pipe",
-    });
-    rmSync(workDir, { recursive: true, force: true });
-  });
-
-  afterEach(() => {
-    process.env = { ...origEnv };
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("clones a git ref on first run", async () => {
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: [
-          {
-            name: "@test/pkg",
-            source: `git+file://${bareRepo}#main`,
-          },
-        ],
-      }),
-    );
-
-    const results = await updateRefs({ cwd: projectDir });
-    expect(results).toHaveLength(1);
-    expect(results[0].kind).toBe("cloned");
-    expect(results[0].pkg).toBe("@test/pkg");
-  });
-
-  it("reports up-to-date on second run without changes", async () => {
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: [
-          {
-            name: "@test/pkg",
-            source: `git+file://${bareRepo}#main`,
-          },
-        ],
-      }),
-    );
-
-    await updateRefs({ cwd: projectDir });
-    const results = await updateRefs({ cwd: projectDir });
-    expect(results).toHaveLength(1);
-    expect(results[0].kind).toBe("up-to-date");
-  });
-
-  it("reports ok for file:// ref pointing to existing path", async () => {
-    const localPkg = join(tmpDir, "local-pkg");
-    mkdirSync(localPkg, { recursive: true });
-
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: [{ name: "@test/local", source: `file://${localPkg}` }],
-      }),
-    );
-
-    const results = await updateRefs({ cwd: projectDir });
-    expect(results).toHaveLength(1);
-    expect(results[0].kind).toBe("ok");
-  });
-
-  it("reports error for file:// ref pointing to missing path", async () => {
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: [
-          { name: "@test/missing", source: "file:///nonexistent/path" },
-        ],
-      }),
-    );
-
-    const results = await updateRefs({ cwd: projectDir });
-    expect(results).toHaveLength(1);
-    expect(results[0].kind).toBe("error");
-  });
-
-  it("skips npm packages", async () => {
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: ["@canonical/design-system"],
-      }),
-    );
-
-    const results = await updateRefs({ cwd: projectDir });
-    expect(results).toHaveLength(1);
-    expect(results[0].kind).toBe("skipped");
-  });
-
-  it("filters by --package flag", async () => {
-    writeFileSync(
-      join(projectDir, "pragma.config.json"),
-      JSON.stringify({
-        packages: [
-          "@canonical/design-system",
-          {
-            name: "@test/pkg",
-            source: `git+file://${bareRepo}#main`,
-          },
-        ],
-      }),
-    );
-
-    const results = await updateRefs({
-      cwd: projectDir,
-      package: "@test/pkg",
-    });
-    expect(results).toHaveLength(1);
-    expect(results[0].pkg).toBe("@test/pkg");
-  });
-
-  it("uses defaults when no config exists", async () => {
-    const results = await updateRefs({ cwd: projectDir });
-    // All 3 defaults are git refs
-    expect(results).toHaveLength(3);
-    for (const r of results) {
-      // Each result is either cloned, up-to-date, or error (network)
-      expect(["cloned", "updated", "up-to-date", "error"]).toContain(r.kind);
-    }
-  });
-});

package/src/domains/refs/operations/updateRefs.ts

@@ -1,180 +0,0 @@
-/**
- * Update operation: fetch/clone git refs into the local cache.
- *
- * Reads project + global config, merges, and for each git ref either
- * clones (first time) or fetches (subsequent). Reports per-package status.
- */
-
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { readConfig } from "#config";
-import { mergeAndParseRefs } from "../../shared/mergeAndParseRefs.js";
-import { cloneRef, fetchRef, pruneCache } from "./gitOps.js";
-import type { PackageRef, RawPackageEntry } from "./parseRef.js";
-import { cacheRoot, gitCacheDir } from "./paths.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface UpdateResult {
-  readonly pkg: string;
-  readonly kind:
-    | "cloned"
-    | "updated"
-    | "up-to-date"
-    | "ok"
-    | "skipped"
-    | "error";
-  readonly detail: string;
-}
-
-export interface UpdateRefsOptions {
-  /** Working directory for reading project config. */
-  cwd: string;
-  /** Update only this package (by name). */
-  package?: string;
-  /** Remove orphaned cache directories. */
-  prune?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Operation
-// ---------------------------------------------------------------------------
-
-/**
- * Update cached git refs.
- *
- * For each configured package:
- * - git refs: clone or fetch into cache
- * - file refs: verify the path exists
- * - npm refs: skip (nothing to update)
- */
-export default async function updateRefs(
-  options: UpdateRefsOptions,
-): Promise<UpdateResult[]> {
-  const config = readConfig(options.cwd);
-  const refs = mergeAndParseRefs(config.packages);
-  const results: UpdateResult[] = [];
-
-  for (const ref of refs) {
-    if (options.package && ref.pkg !== options.package) continue;
-
-    switch (ref.kind) {
-      case "git": {
-        const dest = gitCacheDir(ref.pkg, ref.ref);
-        try {
-          if (existsSync(dest)) {
-            const { updated, oldHead, newHead } = fetchRef(
-              ref.url,
-              ref.ref,
-              dest,
-            );
-            results.push({
-              pkg: ref.pkg,
-              kind: updated ? "updated" : "up-to-date",
-              detail: updated
-                ? `${oldHead.slice(0, 7)} → ${newHead.slice(0, 7)}`
-                : `at ${newHead.slice(0, 7)}`,
-            });
-          } else {
-            cloneRef(ref.url, ref.ref, dest);
-            results.push({
-              pkg: ref.pkg,
-              kind: "cloned",
-              detail: `${ref.url}#${ref.ref}`,
-            });
-          }
-        } catch (err) {
-          results.push({
-            pkg: ref.pkg,
-            kind: "error",
-            detail: err instanceof Error ? err.message : String(err),
-          });
-        }
-        break;
-      }
-
-      case "file": {
-        results.push({
-          pkg: ref.pkg,
-          kind: existsSync(ref.path) ? "ok" : "error",
-          detail: existsSync(ref.path)
-            ? `path exists: ${ref.path}`
-            : `path not found: ${ref.path}`,
-        });
-        break;
-      }
-
-      case "npm": {
-        results.push({
-          pkg: ref.pkg,
-          kind: "skipped",
-          detail: "using npm (no ref configured)",
-        });
-        break;
-      }
-    }
-  }
-
-  if (options.prune) {
-    const pruned = pruneOrphanedCaches(refs);
-    for (const dir of pruned) {
-      results.push({
-        pkg: "(orphan)",
-        kind: "ok",
-        detail: `pruned: ${dir}`,
-      });
-    }
-  }
-
-  return results;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Remove cache directories that don't match any configured git ref.
- * Returns list of removed directories.
- */
-function pruneOrphanedCaches(refs: PackageRef[]): string[] {
-  const validDirs = new Set(
-    refs
-      .filter(
-        (r): r is Extract<PackageRef, { kind: "git" }> => r.kind === "git",
-      )
-      .map((r) => gitCacheDir(r.pkg, r.ref)),
-  );
-
-  const refsDir = join(cacheRoot(), "refs");
-  if (!existsSync(refsDir)) return [];
-
-  const pruned: string[] = [];
-
-  // Walk two levels: @scope/package/ref/
-  for (const scope of safeReaddir(refsDir)) {
-    const scopeDir = join(refsDir, scope);
-    for (const pkg of safeReaddir(scopeDir)) {
-      const pkgDir = join(scopeDir, pkg);
-      for (const ref of safeReaddir(pkgDir)) {
-        const refDir = join(pkgDir, ref);
-        if (!validDirs.has(refDir)) {
-          pruneCache(refDir);
-          pruned.push(refDir);
-        }
-      }
-    }
-  }
-
-  return pruned;
-}
-
-function safeReaddir(dir: string): string[] {
-  try {
-    return readdirSync(dir);
-  } catch {
-    return [];
-  }
-}

package/src/domains/setup/commands/all.ts

@@ -1,58 +0,0 @@
-import type { CommandDefinition, CommandResult } from "@canonical/cli-core";
-import runSetupTask from "../helpers/runSetupTask.js";
-import setupAll from "../operations/setupAll.js";
-
-/**
- * `pragma setup all` command definition.
- *
- * Runs all setup steps (completions, lsp, mcp) as a single
- * composed Task with confirmation gates.
- *
- * @note Impure
- */
-const allCommand: CommandDefinition = {
-  path: ["setup", "all"],
-  description: "Run all setup steps (completions, lsp, mcp)",
-  parameters: [
-    {
-      name: "dryRun",
-      description: "Preview changes without writing",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "undo",
-      description: "Reverse a previous setup",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "yes",
-      description: "Skip all confirmation prompts",
-      type: "boolean",
-      default: false,
-    },
-  ],
-  meta: {
-    examples: [
-      "pragma setup all",
-      "pragma setup all --yes",
-      "pragma setup all --dry-run",
-      "pragma setup all --undo",
-    ],
-  },
-  execute: async (
-    params: Record<string, unknown>,
-    ctx,
-  ): Promise<CommandResult> =>
-    runSetupTask(setupAll(ctx.cwd), {
-      dryRun: params.dryRun === true,
-      undo: params.undo === true,
-      yes: params.yes === true,
-      verbose: ctx.globalFlags.verbose,
-      llm: ctx.globalFlags.llm,
-      format: ctx.globalFlags.format,
-    }),
-};
-
-export default allCommand;

package/src/domains/setup/commands/completions.ts

@@ -1,85 +0,0 @@
-import type { CommandDefinition, CommandResult } from "@canonical/cli-core";
-import type { ShellId } from "../helpers/detectShell.js";
-import runSetupTask from "../helpers/runSetupTask.js";
-import setupCompletions from "../operations/setupCompletions.js";
-
-/**
- * Map boolean shell flags to a ShellId.
- *
- * @param params - Command parameters containing optional shell flags.
- * @returns The forced ShellId, or undefined to auto-detect.
- */
-function resolveForceShell(
-  params: Record<string, unknown>,
-): ShellId | undefined {
-  if (params.zsh === true) return "zsh";
-  if (params.bash === true) return "bash";
-  if (params.fish === true) return "fish";
-  return undefined;
-}
-
-/**
- * `pragma setup completions` command definition.
- *
- * Installs shell completion scripts for bash, zsh, or fish.
- * Auto-detects the shell unless overridden with --zsh, --bash, or --fish.
- *
- * @note Impure
- */
-const completionsCommand: CommandDefinition = {
-  path: ["setup", "completions"],
-  description: "Install shell completion scripts",
-  parameters: [
-    {
-      name: "dryRun",
-      description: "Preview changes without writing",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "undo",
-      description: "Reverse a previous setup",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "zsh",
-      description: "Force zsh completions",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "bash",
-      description: "Force bash completions",
-      type: "boolean",
-      default: false,
-    },
-    {
-      name: "fish",
-      description: "Force fish completions",
-      type: "boolean",
-      default: false,
-    },
-  ],
-  meta: {
-    examples: [
-      "pragma setup completions",
-      "pragma setup completions --zsh",
-      "pragma setup completions --dry-run",
-      "pragma setup completions --undo",
-    ],
-  },
-  execute: async (
-    params: Record<string, unknown>,
-    ctx,
-  ): Promise<CommandResult> =>
-    runSetupTask(setupCompletions(resolveForceShell(params)), {
-      dryRun: params.dryRun === true,
-      undo: params.undo === true,
-      verbose: ctx.globalFlags.verbose,
-      llm: ctx.globalFlags.llm,
-      format: ctx.globalFlags.format,
-    }),
-};
-
-export default completionsCommand;

package/src/domains/setup/commands/entrypoints.test.ts

@@ -1,170 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const runSetupTaskMock = vi.fn();
-const setupAllMock = vi.fn(() => ({ task: "all" }));
-const setupCompletionsMock = vi.fn((shell?: string) => ({
-  task: "completions",
-  shell,
-}));
-const setupLspMock = vi.fn((cwd: string) => ({ task: "lsp", cwd }));
-const setupMcpMock = vi.fn((cwd: string, harness?: string) => ({
-  task: "mcp",
-  cwd,
-  harness,
-}));
-
-vi.mock("../helpers/runSetupTask.js", () => ({
-  default: runSetupTaskMock,
-}));
-
-vi.mock("../operations/setupAll.js", () => ({
-  default: setupAllMock,
-}));
-
-vi.mock("../operations/setupCompletions.js", () => ({
-  default: setupCompletionsMock,
-}));
-
-vi.mock("../operations/setupLsp.js", () => ({
-  default: setupLspMock,
-}));
-
-vi.mock("../operations/setupMcp.js", () => ({
-  default: setupMcpMock,
-}));
-
-describe("setup command entrypoints", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    runSetupTaskMock.mockResolvedValue({ tag: "exit", code: 0 });
-  });
-
-  it("maps setup all flags into runSetupTask", async () => {
-    const { default: allCommand } = await import("./all.js");
-
-    await allCommand.execute(
-      { dryRun: true, undo: true, yes: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: true, format: "json", verbose: true },
-      },
-    );
-
-    expect(setupAllMock).toHaveBeenCalledWith("/workspace");
-    expect(runSetupTaskMock).toHaveBeenCalledWith(
-      { task: "all" },
-      {
-        dryRun: true,
-        undo: true,
-        yes: true,
-        verbose: true,
-        llm: true,
-        format: "json",
-      },
-    );
-  });
-
-  it("resolves zsh, bash, fish, and default completion targets", async () => {
-    const { default: completionsCommand } = await import("./completions.js");
-
-    await completionsCommand.execute(
-      { zsh: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await completionsCommand.execute(
-      { bash: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await completionsCommand.execute(
-      { fish: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await completionsCommand.execute(
-      {},
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-
-    expect(setupCompletionsMock).toHaveBeenNthCalledWith(1, "zsh");
-    expect(setupCompletionsMock).toHaveBeenNthCalledWith(2, "bash");
-    expect(setupCompletionsMock).toHaveBeenNthCalledWith(3, "fish");
-    expect(setupCompletionsMock).toHaveBeenNthCalledWith(4, undefined);
-  });
-
-  it("resolves harness-specific and default mcp setup", async () => {
-    const { default: mcpCommand } = await import("./mcp.js");
-
-    await mcpCommand.execute(
-      { claudeCode: true, yes: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await mcpCommand.execute(
-      { cursor: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await mcpCommand.execute(
-      { windsurf: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-    await mcpCommand.execute(
-      {},
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-
-    expect(setupMcpMock).toHaveBeenNthCalledWith(
-      1,
-      "/workspace",
-      "claude-code",
-    );
-    expect(setupMcpMock).toHaveBeenNthCalledWith(2, "/workspace", "cursor");
-    expect(setupMcpMock).toHaveBeenNthCalledWith(3, "/workspace", "windsurf");
-    expect(setupMcpMock).toHaveBeenNthCalledWith(4, "/workspace", undefined);
-  });
-
-  it("passes cwd and flags through setup lsp", async () => {
-    const { default: lspCommand } = await import("./lsp.js");
-
-    await lspCommand.execute(
-      { dryRun: true, undo: true },
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: true, format: "json", verbose: true },
-      },
-    );
-
-    expect(setupLspMock).toHaveBeenCalledWith("/workspace");
-    expect(runSetupTaskMock).toHaveBeenCalledWith(
-      { task: "lsp", cwd: "/workspace" },
-      {
-        dryRun: true,
-        undo: true,
-        verbose: true,
-        llm: true,
-        format: "json",
-      },
-    );
-  });
-});

package/src/domains/setup/commands/index.ts

@@ -1,7 +0,0 @@
-/** @module Setup command definitions for `pragma setup`. */
-export { default as allCommand } from "./all.js";
-export { default as completionsCommand } from "./completions.js";
-export { default as lspCommand } from "./lsp.js";
-export { default as mcpCommand } from "./mcp.js";
-export { default as setupCommand } from "./setup.js";
-export { default as skillsCommand } from "./skills.js";