@canonical/pragma-cli 0.29.0 → 0.31.0

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

@@ -7,9 +7,13 @@ import buildSkillsCommand from "./skills.js";
 
 const TMP_ROOT = join(tmpdir(), `pragma-setup-cmd-${Date.now()}`);
 
+/** One source per skill directory, matching the loader granularity. */
 const TEST_SOURCES = [
   {
-    dir: join(TMP_ROOT, "node_modules/@canonical/design-system/skills"),
+    dir: join(
+      TMP_ROOT,
+      "node_modules/@canonical/design-system/skills/design-audit",
+    ),
     packageName: "@canonical/design-system",
   },
 ];
@@ -21,7 +25,7 @@ vi.mock("../../skill/helpers/resolveSkillSources.js", () => ({
 beforeAll(() => {
   mkdirSync(TMP_ROOT, { recursive: true });
 
-  const dir = join(TEST_SOURCES[0].dir, "design-audit");
+  const dir = TEST_SOURCES.at(0)?.dir ?? "";
   mkdirSync(dir, { recursive: true });
   writeFileSync(
     join(dir, "SKILL.md"),

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

@@ -2,9 +2,11 @@ import {
   type CommandDefinition,
   type CommandResult,
   createOutputResult,
+  runGeneratorTask,
 } from "@canonical/cli-core";
 import { detectHarnesses } from "@canonical/harnesses";
-import { collectEffects, runTask } from "@canonical/task";
+import { collectEffects } from "@canonical/task";
+import { runTask } from "@canonical/task/node";
 import { PragmaError } from "#error";
 import type { PragmaContext } from "../../shared/context.js";
 import { selectFormatter } from "../../shared/formatters.js";
@@ -94,7 +96,9 @@ export default function buildSkillsCommand(): CommandDefinition {
         });
       }
 
-      const result = await runTask(task);
+      // Run the symlink task through the shared execution core, like the
+      // other setup commands.
+      const result = await runGeneratorTask(task);
 
       const output: SetupSkillsOutput = { result, dryRun: false };
 

package/src/domains/setup/helpers/runSetupTask.test.ts

@@ -1,33 +1,44 @@
-import { info, pure, writeFile } from "@canonical/task";
+import { answerPromptWithDefaults } from "@canonical/cli-core";
+import { pure, type Task, writeFile } from "@canonical/task";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { createInterfaceMock, dryRunMock, runTaskMock, runUndoMock } =
-  vi.hoisted(() => ({
-    createInterfaceMock: vi.fn(),
-    dryRunMock: vi.fn(() => ({ effects: [] })),
-    runTaskMock: vi.fn(),
-    runUndoMock: vi.fn(),
-  }));
-
-async function loadRunSetupTask() {
-  vi.resetModules();
-  vi.doMock("node:readline", () => ({
-    createInterface: createInterfaceMock,
-  }));
-  vi.doMock("@canonical/task", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("@canonical/task")>();
-    return {
-      ...actual,
-      dryRun: dryRunMock,
-      runTask: runTaskMock,
-      runUndo: runUndoMock,
-    };
-  });
-  return (await import("./runSetupTask.js")).default;
-}
-
 import runSetupTask from "./runSetupTask.js";
 
+const {
+  runGeneratorTaskMock,
+  runUndoMock,
+  sessionAnswerMock,
+  sessionDisposeMock,
+} = vi.hoisted(() => ({
+  runGeneratorTaskMock: vi.fn(),
+  runUndoMock: vi.fn(),
+  sessionAnswerMock: vi.fn(),
+  sessionDisposeMock: vi.fn(),
+}));
+
+// runSetupTask orchestrates: dry-run/undo use real formatting and runUndo,
+// while production runs through the shared execution core. Mock the core,
+// runUndo, and the interactive prompt session, so the wiring and lifecycle
+// stay under test with real effect formatting.
+vi.mock("@canonical/cli-core", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@canonical/cli-core")>()),
+  runGeneratorTask: runGeneratorTaskMock,
+}));
+
+vi.mock("@canonical/task/node", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@canonical/task/node")>()),
+  runUndo: runUndoMock,
+}));
+
+vi.mock("../../shared/createInteractivePromptSession.js", () => ({
+  default: () => ({
+    answerPrompt: sessionAnswerMock,
+    wasInterrupted: () => false,
+    dispose: sessionDisposeMock,
+  }),
+}));
+
+const succeed = async (): Promise<undefined> => undefined;
+
 describe("runSetupTask", () => {
   let stderrSpy: ReturnType<typeof vi.spyOn>;
 
@@ -40,13 +51,16 @@ describe("runSetupTask", () => {
 
   afterEach(() => {
     stderrSpy.mockRestore();
-    vi.doUnmock("node:readline");
-    vi.doUnmock("@canonical/task");
   });
 
+  // ===========================================================================
+  // Dry-run mode
+  // ===========================================================================
+
   it("returns output result in dry-run mode", async () => {
-    const task = writeFile("/tmp/test.txt", "hello");
-    const result = await runSetupTask(task, { dryRun: true });
+    const result = await runSetupTask(writeFile("/tmp/test.txt", "hello"), {
+      dryRun: true,
+    });
 
     expect(result.tag).toBe("output");
     if (result.tag === "output") {
@@ -54,176 +68,152 @@ describe("runSetupTask", () => {
       expect(text).toContain("Dry run");
       expect(text).toContain("/tmp/test.txt");
     }
+    expect(runGeneratorTaskMock).not.toHaveBeenCalled();
   });
 
   it("returns json output in dry-run + json mode", async () => {
-    const task = writeFile("/tmp/test.txt", "hello");
-    const result = await runSetupTask(task, {
+    const result = await runSetupTask(writeFile("/tmp/test.txt", "hello"), {
       dryRun: true,
       format: "json",
     });
 
     expect(result.tag).toBe("output");
     if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      const parsed = JSON.parse(text);
+      const parsed = JSON.parse(result.render.plain(result.value));
       expect(Array.isArray(parsed)).toBe(true);
       expect(parsed[0].action).toBe("WriteFile");
     }
   });
 
   it("returns llm markdown in dry-run + llm mode", async () => {
-    const task = writeFile("/tmp/test.txt", "hello");
-    const result = await runSetupTask(task, { dryRun: true, llm: true });
+    const result = await runSetupTask(writeFile("/tmp/test.txt", "hello"), {
+      dryRun: true,
+      llm: true,
+    });
 
     expect(result.tag).toBe("output");
     if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toContain("## Dry Run");
-      expect(text).toContain("WriteFile");
+      expect(result.render.plain(result.value)).toContain("Dry Run");
     }
   });
 
-  it("returns exit 0 on successful execution with --yes", async () => {
-    const task = info("test message");
-    const result = await runSetupTask(task, { yes: true });
+  it("shows the no-visible-effects message when a dry-run collects none", async () => {
+    const result = await runSetupTask(pure(undefined) as Task<void>, {
+      dryRun: true,
+      verbose: false,
+    });
 
-    expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(0);
+    expect(result.tag).toBe("output");
+    if (result.tag === "output") {
+      expect(result.render.plain(result.value)).toContain("no visible effects");
     }
   });
 
-  it("returns exit 0 for pure task", async () => {
-    const task = pure(undefined);
-    const result = await runSetupTask(task, { yes: true });
+  // ===========================================================================
+  // Production execution — through the shared execution core
+  // ===========================================================================
+
+  it("runs production through the shared execution core and returns exit 0", async () => {
+    runGeneratorTaskMock.mockImplementation(succeed);
 
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), { yes: true });
+
+    expect(runGeneratorTaskMock).toHaveBeenCalledTimes(1);
     expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(0);
-    }
+    if (result.tag === "exit") expect(result.code).toBe(0);
   });
 
-  it("shows no visible effects message for pure dry-run", async () => {
-    const task = pure(undefined);
-    const result = await runSetupTask(task, { dryRun: true });
+  it("wires the auto-confirm handler in yes mode", async () => {
+    runGeneratorTaskMock.mockImplementation(async (_task, options) => {
+      expect(options.promptHandler).toBe(answerPromptWithDefaults);
+      return succeed();
+    });
 
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toContain("no visible effects");
-    }
+    await runSetupTask(writeFile("/tmp/x", "y"), { yes: true });
+    expect(runGeneratorTaskMock).toHaveBeenCalledTimes(1);
   });
 
-  it("returns exit 0 in undo mode for a pure task", async () => {
-    const task = pure(undefined);
-    const result = await runSetupTask(task, { undo: true, yes: true });
+  it("wires an interactive prompt session when not in yes mode and disposes it", async () => {
+    runGeneratorTaskMock.mockImplementation(async (_task, options) => {
+      expect(options.promptHandler).toBe(sessionAnswerMock);
+      expect(sessionDisposeMock).not.toHaveBeenCalled();
+      return succeed();
+    });
 
-    expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(0);
-    }
-    expect(stderrSpy).toHaveBeenCalledWith("Nothing to undo.\n");
+    await runSetupTask(writeFile("/tmp/x", "y"), {});
+    expect(runGeneratorTaskMock).toHaveBeenCalledTimes(1);
+    expect(sessionDisposeMock).toHaveBeenCalledTimes(1);
   });
 
-  it("auto-confirms select, multiselect, confirm, and text prompts in yes mode", async () => {
-    runTaskMock.mockImplementation(async (_task, options) => {
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: { type: "confirm", default: false, message: "Continue?" },
-        }),
-      ).toBe(false);
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: {
-            type: "select",
-            choices: [{ value: "zsh" }],
-            message: "Shell?",
-          },
-        }),
-      ).toBe("zsh");
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: { type: "multiselect", message: "Pick many" },
-        }),
-      ).toEqual([]);
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: { type: "input", message: "Name?" },
-        }),
-      ).toBe("");
-    });
+  it("disposes the prompt session even when production execution fails", async () => {
+    runGeneratorTaskMock.mockRejectedValue(new Error("boom"));
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, { yes: true });
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {});
 
     expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(0);
-    }
+    expect(sessionDisposeMock).toHaveBeenCalledTimes(1);
   });
 
-  it("uses interactive confirm defaults and suppresses debug logs unless verbose", async () => {
-    createInterfaceMock.mockReturnValue({
-      question: (_prompt: string, cb: (answer: string) => void) => cb(""),
-      close: vi.fn(),
-    });
-    runTaskMock.mockImplementation(async (_task, options) => {
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: { type: "confirm", default: true, message: "Continue?" },
-        }),
-      ).toBe(true);
+  it("suppresses debug logs unless verbose during production", async () => {
+    runGeneratorTaskMock.mockImplementation(async (_task, options) => {
       options.onLog("debug", "hidden");
       options.onLog("info", "shown");
+      return succeed();
     });
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, {});
+    await runSetupTask(writeFile("/tmp/x", "y"), { yes: true });
 
-    expect(result.tag).toBe("exit");
     expect(stderrSpy).toHaveBeenCalledWith("shown\n");
     expect(stderrSpy).not.toHaveBeenCalledWith("hidden\n");
   });
 
-  it("returns false for explicit negative interactive confirmation", async () => {
-    createInterfaceMock.mockReturnValue({
-      question: (_prompt: string, cb: (answer: string) => void) => cb("n"),
-      close: vi.fn(),
+  it("emits debug logs when verbose during production", async () => {
+    runGeneratorTaskMock.mockImplementation(async (_task, options) => {
+      options.onLog("debug", "shown-debug");
+      return succeed();
     });
-    runTaskMock.mockImplementation(async (_task, options) => {
-      expect(
-        await options.promptHandler({
-          _tag: "Prompt",
-          question: { type: "confirm", default: false, message: "Continue?" },
-        }),
-      ).toBe(false);
-    });
-
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, {});
 
-    expect(result.tag).toBe("exit");
+    await runSetupTask(writeFile("/tmp/x", "y"), { yes: true, verbose: true });
+    expect(stderrSpy).toHaveBeenCalledWith("shown-debug\n");
   });
 
   it("returns exit 1 when production execution fails", async () => {
-    runTaskMock.mockRejectedValue(new Error("permission denied"));
+    runGeneratorTaskMock.mockRejectedValue(new Error("permission denied"));
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, { yes: true });
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), { yes: true });
 
     expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(1);
-    }
+    if (result.tag === "exit") expect(result.code).toBe(1);
     expect(stderrSpy).toHaveBeenCalledWith("Setup failed: permission denied\n");
   });
 
+  it("stringifies a non-Error production rejection", async () => {
+    runGeneratorTaskMock.mockRejectedValue("raw failure");
+
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), { yes: true });
+
+    expect(result.tag).toBe("exit");
+    if (result.tag === "exit") expect(result.code).toBe(1);
+    expect(stderrSpy).toHaveBeenCalledWith("Setup failed: raw failure\n");
+  });
+
+  // ===========================================================================
+  // Undo mode
+  // ===========================================================================
+
+  it("reports nothing to undo when no undos are collected", async () => {
+    runUndoMock.mockResolvedValue({ undoCount: 0 });
+
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {
+      undo: true,
+      yes: true,
+    });
+
+    expect(result.tag).toBe("exit");
+    if (result.tag === "exit") expect(result.code).toBe(0);
+    expect(stderrSpy).toHaveBeenCalledWith("Nothing to undo.\n");
+  });
+
   it("writes verbose undo logs and the singular completion message", async () => {
     runUndoMock.mockImplementation(async (_task, options) => {
       options.onLog("debug", "debug line");
@@ -231,8 +221,7 @@ describe("runSetupTask", () => {
       return { undoCount: 1 };
     });
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, {
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {
       undo: true,
       yes: true,
       verbose: true,
@@ -249,8 +238,7 @@ describe("runSetupTask", () => {
   it("writes the plural undo completion message", async () => {
     runUndoMock.mockResolvedValue({ undoCount: 2 });
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, {
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {
       undo: true,
       yes: true,
     });
@@ -264,16 +252,26 @@ describe("runSetupTask", () => {
   it("returns exit 1 when undo fails", async () => {
     runUndoMock.mockRejectedValue(new Error("cannot undo"));
 
-    const runSetupTaskWithMocks = await loadRunSetupTask();
-    const result = await runSetupTaskWithMocks({} as never, {
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {
       undo: true,
       yes: true,
     });
 
     expect(result.tag).toBe("exit");
-    if (result.tag === "exit") {
-      expect(result.code).toBe(1);
-    }
+    if (result.tag === "exit") expect(result.code).toBe(1);
     expect(stderrSpy).toHaveBeenCalledWith("Undo failed: cannot undo\n");
   });
+
+  it("stringifies a non-Error undo rejection", async () => {
+    runUndoMock.mockRejectedValue("raw undo failure");
+
+    const result = await runSetupTask(writeFile("/tmp/x", "y"), {
+      undo: true,
+      yes: true,
+    });
+
+    expect(result.tag).toBe("exit");
+    if (result.tag === "exit") expect(result.code).toBe(1);
+    expect(stderrSpy).toHaveBeenCalledWith("Undo failed: raw undo failure\n");
+  });
 });

package/src/domains/setup/helpers/runSetupTask.ts

@@ -1,18 +1,17 @@
-import { createInterface } from "node:readline";
 import {
+  answerPromptWithDefaults,
   type CommandResult,
   createExitResult,
   createOutputResult,
   formatEffectLine,
   isVisibleEffect,
+  runGeneratorTask,
 } from "@canonical/cli-core";
-import {
-  dryRun,
-  type Effect,
-  runTask,
-  runUndo,
-  type Task,
-} from "@canonical/task";
+import { dryRun, type Effect, type Task } from "@canonical/task";
+import { runUndo } from "@canonical/task/node";
+import createInteractivePromptSession, {
+  type InteractivePromptSession,
+} from "../../shared/createInteractivePromptSession.js";
 import type { LogLevel } from "../types.js";
 
 /** Options controlling how {@link runSetupTask} executes. */
@@ -26,55 +25,41 @@ export interface SetupTaskOptions {
 }
 
 /**
- * Auto-confirm prompt handler for `--yes` mode.
- *
- * @param effect - A Prompt effect to resolve.
- * @returns The default value for the prompt type.
+ * Pick the prompt handler for a run: auto-confirm defaults under `--yes`, else
+ * an interactive readline session (whose lifetime the caller owns via the
+ * returned `dispose`).
  */
-function autoConfirmHandler(
-  effect: Effect & { _tag: "Prompt" },
-): Promise<unknown> {
-  const q = effect.question;
-  if (q.type === "confirm") return Promise.resolve(q.default ?? true);
-  if (q.type === "select")
-    return Promise.resolve(q.default ?? q.choices[0]?.value);
-  if (q.type === "multiselect") return Promise.resolve(q.default ?? []);
-  return Promise.resolve(q.default ?? "");
+function selectPromptHandler(yes: boolean): {
+  handler: (effect: Effect & { _tag: "Prompt" }) => Promise<unknown>;
+  wasInterrupted: () => boolean;
+  dispose: () => void;
+} {
+  if (yes) {
+    return {
+      handler: answerPromptWithDefaults,
+      wasInterrupted: () => false,
+      dispose: () => {},
+    };
+  }
+  const session: InteractivePromptSession = createInteractivePromptSession();
+  return {
+    handler: session.answerPrompt,
+    wasInterrupted: session.wasInterrupted,
+    dispose: session.dispose,
+  };
 }
 
 /**
- * Interactive prompt handler using readline on stdin/stderr.
- * Supports confirm prompts; other types fall back to defaults.
- *
- * @param effect - A Prompt effect to resolve interactively.
- * @returns The user's answer.
+ * Build a task log sink that writes to stderr, hiding debug lines unless
+ * verbose is set.
  */
-async function interactivePromptHandler(
-  effect: Effect & { _tag: "Prompt" },
-): Promise<unknown> {
-  const q = effect.question;
-
-  if (q.type === "confirm") {
-    const defaultYes = q.default !== false;
-    const hint = defaultYes ? "Y/n" : "y/N";
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stderr,
-    });
-
-    const answer = await new Promise<string>((resolve) => {
-      rl.question(`${q.message} [${hint}] `, (ans) => {
-        rl.close();
-        resolve(ans.trim());
-      });
-    });
-
-    if (answer === "") return defaultYes;
-    return answer.toLowerCase().startsWith("y");
-  }
-
-  // Non-confirm prompts fall back to defaults in D15
-  return q.default;
+function createStderrLogger(
+  verbose: boolean,
+): (level: LogLevel, message: string) => void {
+  return (level, message) => {
+    if (level === "debug" && !verbose) return;
+    process.stderr.write(`${message}\n`);
+  };
 }
 
 /**
@@ -150,7 +135,8 @@ function formatDryRunJson(effects: readonly Effect[]): string {
  * Supports three execution modes:
  * - `--dry-run`: collects effects without executing, formats for display.
  * - `--undo`: walks the task tree, collects undo operations, executes in reverse.
- * - default: interactive execution with readline-based prompts on stderr.
+ * - default: execution through {@link runGeneratorTask}, with readline-based
+ *   prompts on stderr.
  *
  * @param task - The setup Task to execute.
  * @param options - Execution options (dryRun, undo, yes, verbose, llm, format).
@@ -182,14 +168,12 @@ export default async function runSetupTask(
 
   // Undo mode: walk the task tree, collect undos, execute in reverse
   if (options.undo) {
-    const promptHandler = options.yes
-      ? autoConfirmHandler
-      : interactivePromptHandler;
-
-    const onLog = (level: LogLevel, message: string): void => {
-      if (level === "debug" && !verbose) return;
-      process.stderr.write(`${message}\n`);
-    };
+    const {
+      handler: promptHandler,
+      wasInterrupted,
+      dispose,
+    } = selectPromptHandler(options.yes ?? false);
+    const onLog = createStderrLogger(verbose);
 
     try {
       const result = await runUndo(task, { promptHandler, onLog });
@@ -202,28 +186,36 @@ export default async function runSetupTask(
       }
       return createExitResult(0);
     } catch (err) {
+      if (wasInterrupted()) {
+        return createExitResult(130);
+      }
       const message = err instanceof Error ? err.message : String(err);
       process.stderr.write(`Undo failed: ${message}\n`);
       return createExitResult(1);
+    } finally {
+      dispose();
     }
   }
 
   // Production execution
-  const promptHandler = options.yes
-    ? autoConfirmHandler
-    : interactivePromptHandler;
-
-  const onLog = (level: LogLevel, message: string): void => {
-    if (level === "debug" && !verbose) return;
-    process.stderr.write(`${message}\n`);
-  };
+  const {
+    handler: promptHandler,
+    wasInterrupted,
+    dispose,
+  } = selectPromptHandler(options.yes ?? false);
+  const onLog = createStderrLogger(verbose);
 
   try {
-    await runTask(task, { promptHandler, onLog });
+    await runGeneratorTask(task, { promptHandler, onLog });
     return createExitResult(0);
   } catch (err) {
+    if (wasInterrupted()) {
+      return createExitResult(130);
+    }
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`Setup failed: ${message}\n`);
     return createExitResult(1);
+  } finally {
+    dispose();
   }
 }

package/src/domains/setup/index.ts

@@ -2,21 +2,25 @@
 
 import type { CommandDefinition } from "@canonical/cli-core";
 import {
-  allCommand,
   completionsCommand,
   lspCommand,
   mcpCommand,
+  setupCommand,
   skillsCommand,
 } from "./commands/index.js";
 
 /**
  * Return all setup command definitions.
  *
- * @returns An array of CommandDefinitions for the setup subcommands.
+ * The top-level `pragma setup` is a summon-generator-backed command (replacing
+ * the former `setup all`); the granular `setup <step>` verbs remain for
+ * targeted, scriptable configuration of a single concern.
+ *
+ * @returns An array of CommandDefinitions for the setup command and its verbs.
  */
 export function commands(): CommandDefinition[] {
   return [
-    allCommand,
+    setupCommand(),
     lspCommand,
     mcpCommand,
     completionsCommand,