@rbbtsn0w/adg 0.1.0-alpha.1

package/src/commands/list.ts

@@ -0,0 +1,28 @@
+import { installedPluginDir, lockPath } from "../paths.ts";
+import { readLock } from "../lock.ts";
+import { readManifest } from "../manifest.ts";
+import { exposedContents, pluginContents, type PluginContents } from "../components.ts";
+import type { LockEntry } from "../types.ts";
+
+export type { PluginContents };
+
+export interface ListedPlugin extends LockEntry {
+  name: string;
+  /** What the installed plugin exposes (honoring any partial-install selection). */
+  contents?: PluginContents;
+}
+
+/** List plugins recorded in a plugins directory's .plugin-lock.json. */
+export function listPlugins(pluginsDir: string): ListedPlugin[] {
+  const lock = readLock(lockPath(pluginsDir));
+  return Object.entries(lock.plugins).map(([name, entry]) => {
+    const dir = installedPluginDir(pluginsDir, name, entry.origin);
+    let contents: PluginContents | undefined;
+    try {
+      contents = exposedContents(pluginContents(dir, readManifest(dir)), entry.selection);
+    } catch {
+      contents = undefined; // no/invalid manifest on disk — show provenance only
+    }
+    return { name, ...entry, contents };
+  });
+}

package/src/commands/marketplace.ts

@@ -0,0 +1,198 @@
+import type { AdapterTarget } from "../adapters/index.ts";
+import type { GitRunner } from "../sources.ts";
+import type { PluginSource } from "../types.ts";
+import { lockPath } from "../paths.ts";
+import { readLock } from "../lock.ts";
+import { addPlugins, type InstallResult } from "./install.ts";
+import { removePlugin } from "./remove.ts";
+import type { AgentScope } from "../agents/index.ts";
+
+/**
+ * The marketplace layer is a *view* over installed plugins grouped by their
+ * source, not a separate registry. Every plugin records where it came from in
+ * `lock.origin`; a "marketplace" is just the set of plugins sharing a source.
+ */
+
+/** Active-scope context, used to make "source not found" errors actionable. */
+export interface ScopeInfo {
+  /** Human label for the active scope: "project", "global", or an explicit dir. */
+  label: string;
+  /** The global plugins dir, so we can suggest `-g` when a source is only there. */
+  globalDir?: string;
+}
+
+export interface MarketplaceScope {
+  pluginsDir: string;
+  now?: string;
+  /** Where the active pluginsDir came from, for scope-aware error messages. */
+  scope?: ScopeInfo;
+}
+
+/**
+ * A stable key identifying the source a plugin came from. GitHub/git plugins
+ * group by repo/url (the marketplace root, ignoring per-plugin sub-paths);
+ * local installs share a single "(local)" bucket since their original source
+ * directory isn't recoverable for re-sync.
+ */
+export function sourceKey(origin: PluginSource): string {
+  switch (origin.type) {
+    case "github":
+      return origin.repo;
+    case "git":
+      return origin.url;
+    case "local":
+      return "(local)";
+  }
+}
+
+/** True for sources that can be re-fetched (have a recoverable remote spec). */
+function isRemoteKey(key: string): boolean {
+  return key !== "(local)";
+}
+
+export interface MarketplaceGroup {
+  /** Source key (owner/repo, git url, or "(local)"). */
+  source: string;
+  /** ref shared by the group's plugins, if any. */
+  ref?: string;
+  /** Installed plugin names from this source. */
+  installed: string[];
+  /** Whether this source can be re-synced (remote). */
+  remote: boolean;
+}
+
+/** Group installed plugins by source, read straight from the lock. */
+export function marketplaceList(opts: { pluginsDir: string }): MarketplaceGroup[] {
+  const lock = readLock(lockPath(opts.pluginsDir));
+  const groups = new Map<string, { ref?: string; installed: string[] }>();
+
+  for (const [name, entry] of Object.entries(lock.plugins)) {
+    const key = sourceKey(entry.origin);
+    const ref = entry.origin.type === "github" || entry.origin.type === "git" ? entry.origin.ref : undefined;
+    const g = groups.get(key) ?? { ref, installed: [] };
+    g.installed.push(name);
+    if (g.ref === undefined && ref !== undefined) g.ref = ref;
+    groups.set(key, g);
+  }
+
+  return [...groups.entries()]
+    .map(([source, g]) => ({
+      source,
+      ...(g.ref ? { ref: g.ref } : {}),
+      installed: g.installed.sort(),
+      remote: isRemoteKey(source),
+    }))
+    .sort((a, b) => a.source.localeCompare(b.source));
+}
+
+/**
+ * Find one source group by key, or throw with the available keys. The error is
+ * scope-aware: it names the scope/path it searched, and — when the source isn't
+ * here but exists globally — suggests re-running with `-g`.
+ */
+function requireGroup(pluginsDir: string, source: string, scope?: ScopeInfo): MarketplaceGroup {
+  const groups = marketplaceList({ pluginsDir });
+  const hit = groups.find((g) => g.source === source);
+  if (hit) return hit;
+
+  const keys = groups.map((g) => g.source).join(", ") || "(none)";
+  const where = scope?.label ? `${scope.label}: ${pluginsDir}` : pluginsDir;
+  let msg = `no installed source "${source}" in ${where}. Known sources: ${keys}`;
+
+  if (scope?.globalDir && scope.globalDir !== pluginsDir) {
+    const inGlobal = marketplaceList({ pluginsDir: scope.globalDir }).some((g) => g.source === source);
+    if (inGlobal) msg += ` — found in global; did you mean \`-g\`?`;
+  }
+  throw new Error(msg);
+}
+
+export interface MarketplaceUpgradeResult {
+  source: string;
+  /** Plugins re-installed/updated from the source. */
+  updated: InstallResult[];
+  converted: string[];
+  /** Discovered in the source but not installed (offered for `--all`). */
+  available: string[];
+}
+
+/**
+ * Re-fetch a source and update the plugins installed from it. By default only
+ * already-installed plugins are refreshed; `all` also installs everything new
+ * the source now offers. With no `source`, every remote source is upgraded.
+ */
+export async function marketplaceUpgrade(
+  opts: MarketplaceScope & {
+    source?: string;
+    all?: boolean;
+    targets?: AdapterTarget[];
+    gitRunner?: GitRunner;
+    /** Re-activate the agents after upgrade (set by the CLI; off by default). */
+    activate?: boolean;
+    /** Install scope for re-activation after upgrade. */
+    agentScope?: AgentScope;
+  },
+): Promise<MarketplaceUpgradeResult[]> {
+  const groups = opts.source
+    ? [requireGroup(opts.pluginsDir, opts.source, opts.scope)]
+    : marketplaceList({ pluginsDir: opts.pluginsDir }).filter((g) => g.remote);
+
+  if (opts.source && !groups[0]!.remote) {
+    throw new Error(`source "${opts.source}" is local and cannot be re-synced; re-run \`adg plugins add\`.`);
+  }
+  if (groups.length === 0) {
+    throw new Error(`no remote sources installed in ${opts.pluginsDir}`);
+  }
+
+  const now = opts.now ?? new Date().toISOString();
+  const results: MarketplaceUpgradeResult[] = [];
+
+  for (const group of groups) {
+    const { installed, converted, available } = await addPlugins({
+      spec: group.source,
+      pluginsDir: opts.pluginsDir,
+      ref: group.ref,
+      // Default: refresh what's installed. --all: install everything too.
+      ...(opts.all ? { all: true } : { plugins: group.installed }),
+      targets: opts.targets,
+      marketplaceName: group.source,
+      gitRunner: opts.gitRunner,
+      // Re-activate so the agents pick up the upgraded content, not just the store.
+      activate: opts.activate,
+      scope: opts.agentScope,
+      now,
+    });
+    const installedSet = new Set(group.installed);
+    results.push({
+      source: group.source,
+      updated: installed,
+      converted,
+      available: available.filter((n) => !installedSet.has(n)),
+    });
+  }
+
+  return results;
+}
+
+export interface MarketplaceRemoveResult {
+  source: string;
+  removed: string[];
+}
+
+/** Uninstall every plugin that came from a given source (and from the agents). */
+export function marketplaceRemove(
+  opts: MarketplaceScope & { source: string; force?: boolean; deactivate?: boolean; agentScope?: AgentScope },
+): MarketplaceRemoveResult {
+  const group = requireGroup(opts.pluginsDir, opts.source, opts.scope);
+  const removed: string[] = [];
+  for (const name of group.installed) {
+    removePlugin({
+      pluginsDir: opts.pluginsDir,
+      name,
+      force: opts.force,
+      deactivate: opts.deactivate,
+      scope: opts.agentScope,
+    });
+    removed.push(name);
+  }
+  return { source: opts.source, removed };
+}

package/src/commands/migrate.ts

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { lockPath, marketplacePath, marketplaceSourcePath, pluginDir } from "../paths.ts";
+import { readLock } from "../lock.ts";
+import { readMarketplace, upsertMarketplacePlugin, writeMarketplace } from "../marketplace.ts";
+
+export interface MigrateMove {
+  name: string;
+  from: string;
+  to: string;
+}
+
+export interface MigrateResult {
+  /** Plugin directories relocated into their per-marketplace bucket. */
+  moved: MigrateMove[];
+  /** Already in the right place (or local/flat) — left untouched. */
+  unchanged: string[];
+  /** In the lock but no directory found at either the old or new path. */
+  missing: string[];
+}
+
+/**
+ * Migrate a flat plugins directory to the per-marketplace nested layout.
+ *
+ * For every locked plugin, move `<pluginsDir>/<name>` to the origin-derived
+ * `<pluginsDir>/<segment>/<name>` (remote sources only; local installs stay
+ * flat) and rewrite its marketplace.json `source.path` to match. Idempotent:
+ * plugins already at their target path are reported as unchanged.
+ */
+export function migrateLayout(pluginsDir: string): MigrateResult {
+  const lock = readLock(lockPath(pluginsDir));
+  const moved: MigrateMove[] = [];
+  const unchanged: string[] = [];
+  const missing: string[] = [];
+
+  const marketFile = marketplacePath(pluginsDir);
+  const market = readMarketplace(marketFile, "");
+  let marketDirty = false;
+
+  for (const [name, entry] of Object.entries(lock.plugins)) {
+    const flat = join(pluginsDir, name);
+    const target = pluginDir(pluginsDir, name, entry.origin);
+
+    if (target === flat) {
+      unchanged.push(name);
+      continue;
+    }
+
+    if (existsSync(target)) {
+      // Already migrated; nothing to move, but make sure the export agrees.
+      if (rewriteMarketplacePath(market, name, pluginsDir, target)) marketDirty = true;
+      unchanged.push(name);
+      continue;
+    }
+
+    if (!existsSync(flat)) {
+      missing.push(name);
+      continue;
+    }
+
+    mkdirSync(dirname(target), { recursive: true });
+    renameSync(flat, target);
+    if (rewriteMarketplacePath(market, name, pluginsDir, target)) marketDirty = true;
+    moved.push({ name, from: flat, to: target });
+  }
+
+  if (marketDirty) writeMarketplace(marketFile, market);
+  return { moved, unchanged, missing };
+}
+
+/** Point a marketplace entry's `source.path` at the plugin's on-disk dir. */
+function rewriteMarketplacePath(
+  market: ReturnType<typeof readMarketplace>,
+  name: string,
+  pluginsDir: string,
+  dir: string,
+): boolean {
+  const existing = market.plugins.find((p) => p.name === name);
+  if (!existing) return false;
+  const path = marketplaceSourcePath(pluginsDir, dir);
+  if (existing.source.path === path) return false;
+  upsertMarketplacePlugin(market, { ...existing, source: { ...existing.source, path } });
+  return true;
+}

package/src/commands/multiselect-skills.ts

@@ -0,0 +1,137 @@
+import { MultiSelectPrompt } from "@clack/core";
+import pc from "picocolors";
+
+/**
+ * A skills multiselect with an on-demand description toggle. `@clack/prompts`'
+ * `multiselect` can't intercept extra keys, so this builds directly on
+ * `@clack/core`'s `MultiSelectPrompt` and replicates clack's chrome, adding a
+ * `d` key that lazily loads and inlines each skill's description as a hint.
+ *
+ * Descriptions are read only while the toggle is on (and cached by the loader),
+ * so a list of many skills costs nothing until the user actually asks for them.
+ */
+
+// Match @clack/prompts' unicode-aware glyphs so the picker is visually seamless.
+const unicode =
+  process.platform !== "win32" ||
+  Boolean(process.env.WT_SESSION) ||
+  process.env.TERM_PROGRAM === "vscode" ||
+  process.env.TERM === "xterm-256color";
+const g = (a: string, b: string) => (unicode ? a : b);
+const S_BAR = g("│", "|");
+const S_BAR_END = g("└", "—");
+const S_STEP_ACTIVE = g("◆", "*");
+const S_STEP_SUBMIT = g("◇", "o");
+const S_STEP_CANCEL = g("■", "x");
+const S_CHECK_ACTIVE = g("◻", "[•]");
+const S_CHECK_SELECTED = g("◼", "[+]");
+const S_CHECK_INACTIVE = g("◻", "[ ]");
+
+export interface SkillOption {
+  value: string;
+  label: string;
+}
+
+export type RowKind = "active" | "selected" | "active-selected" | "inactive";
+
+/** Format one option row, appending the description as a dim hint when present. */
+export function formatSkillRow(label: string, hint: string | undefined, kind: RowKind): string {
+  const tail = hint ? `  ${pc.dim(hint)}` : "";
+  switch (kind) {
+    case "active":
+      return `${pc.cyan(S_CHECK_ACTIVE)} ${label}${tail}`;
+    case "active-selected":
+      return `${pc.green(S_CHECK_SELECTED)} ${label}${tail}`;
+    case "selected":
+      return `${pc.green(S_CHECK_SELECTED)} ${pc.dim(label)}${tail}`;
+    default:
+      return `${pc.dim(S_CHECK_INACTIVE)} ${pc.dim(label)}`;
+  }
+}
+
+export interface BuildRowsState {
+  cursor: number;
+  selected: string[];
+  /** When false, `loadDescription` is never called — this is the lazy gate. */
+  showDesc: boolean;
+  loadDescription: (value: string) => string | undefined;
+}
+
+/**
+ * Build the rendered option rows. Descriptions are resolved only when
+ * `showDesc` is true, so the picker performs zero SKILL.md reads until the user
+ * presses `d`. Exported as the pure core of the picker for direct testing.
+ */
+export function buildSkillRows(options: SkillOption[], state: BuildRowsState): string[] {
+  return options.map((o, i) => {
+    const sel = state.selected.includes(o.value);
+    const active = i === state.cursor;
+    const hint = state.showDesc ? state.loadDescription(o.value) : undefined;
+    const kind: RowKind = active && sel ? "active-selected" : sel ? "selected" : active ? "active" : "inactive";
+    return formatSkillRow(o.label, hint, kind);
+  });
+}
+
+export interface MultiselectSkillsOptions {
+  message: string;
+  options: SkillOption[];
+  initialValues: string[];
+  /** Lazy, cached description lookup; invoked only while the toggle is on. */
+  loadDescription: (value: string) => string | undefined;
+  /** Injection seams for tests; default to process.stdin/stdout. */
+  input?: NodeJS.ReadStream;
+  output?: NodeJS.WriteStream;
+}
+
+/** Resolves to the chosen values, or a cancel symbol (use `isCancel` to detect). */
+export function multiselectSkills(opts: MultiselectSkillsOptions): Promise<string[] | symbol> {
+  let showDesc = false;
+
+  const symbol = (state: string): string => {
+    if (state === "submit") return pc.green(S_STEP_SUBMIT);
+    if (state === "cancel") return pc.red(S_STEP_CANCEL);
+    return pc.cyan(S_STEP_ACTIVE);
+  };
+  const footer = () =>
+    pc.dim(`space ${pc.gray("toggle")} · a ${pc.gray("all")} · d ${pc.gray(showDesc ? "hide" : "show")} descriptions`);
+
+  const prompt = new MultiSelectPrompt({
+    input: opts.input,
+    output: opts.output,
+    options: opts.options,
+    initialValues: opts.initialValues,
+    required: true,
+    validate(this: { required?: boolean }, value: unknown) {
+      if (this.required && Array.isArray(value) && value.length === 0) {
+        return "Please select at least one option.";
+      }
+      return undefined;
+    },
+    render(this: { state: string; value: string[]; cursor: number; options: SkillOption[] }) {
+      const head = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+      if (this.state === "submit" || this.state === "cancel") {
+        const chosen = this.options
+          .filter((o) => this.value.includes(o.value))
+          .map((o) => pc.dim(o.label))
+          .join(pc.dim(", "));
+        return `${head}${pc.gray(S_BAR)}  ${chosen || pc.dim("none")}`;
+      }
+      const rows = buildSkillRows(this.options, {
+        cursor: this.cursor,
+        selected: this.value,
+        showDesc,
+        loadDescription: opts.loadDescription,
+      }).join(`\n${pc.cyan(S_BAR)}  `);
+      return `${head}${pc.cyan(S_BAR)}  ${rows}\n${pc.cyan(S_BAR)}  ${footer()}\n${pc.cyan(S_BAR_END)}\n`;
+    },
+  });
+
+  // `a` (toggle-all) is bound by MultiSelectPrompt itself; `d` is free for us.
+  // Touching showDesc here re-renders on the same keypress (onKeypress renders
+  // after emitting "key"), so the first `d` press shows descriptions at once.
+  (prompt as unknown as { on(e: string, cb: (c: string) => void): void }).on("key", (c) => {
+    if (c === "d") showDesc = !showDesc;
+  });
+
+  return (prompt as unknown as { prompt(): Promise<string[] | symbol> }).prompt();
+}

package/src/commands/remove.ts

@@ -0,0 +1,136 @@
+import { existsSync, lstatSync, readdirSync, readlinkSync, rmdirSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { claudeSkillsDir, lockPath, marketplacePath, pluginDir } from "../paths.ts";
+import { readLock, removeEntry, writeLock } from "../lock.ts";
+import { readMarketplace, removeMarketplacePlugin, writeMarketplace } from "../marketplace.ts";
+import { basename } from "node:path";
+import { resolveAgents, type Agent, type AgentScope, type AgentSyncResult } from "../agents/index.ts";
+
+export interface RemoveOptions {
+  /** Plugins directory the plugin lives in. */
+  pluginsDir: string;
+  name: string;
+  /** Remove even if other installed plugins depend on it. */
+  force?: boolean;
+  cwd?: string;
+  /** Also uninstall the plugin from the agents via their CLIs. */
+  deactivate?: boolean;
+  /** Install scope to uninstall from; "user" (global) or "project". */
+  scope?: AgentScope;
+  /** Injection seam for tests; defaults to every registered agent. */
+  agents?: Agent[];
+}
+
+export interface RemoveResult {
+  name: string;
+  /** Plugin directory that was deleted, if it existed. */
+  removedDir?: string;
+  /** Claude skills symlinks that were cleaned up. */
+  unlinked: string[];
+  removedFromLock: boolean;
+  removedFromMarketplace: boolean;
+  /** Per-agent deactivation outcome (when `deactivate` was set). */
+  agents?: AgentSyncResult[];
+}
+
+/**
+ * Remove an installed plugin: delete its directory, drop it from
+ * `.plugin-lock.json` and `marketplace.json`, and clean up any Claude
+ * skills-dir symlinks that pointed at it. Only paths under `pluginsDir` (plus
+ * symlinks that resolve back into it) are touched.
+ *
+ * Refuses when another installed plugin depends on it, unless `force` is set.
+ */
+export function removePlugin(opts: RemoveOptions): RemoveResult {
+  const { name } = opts;
+  const cwd = opts.cwd ?? process.cwd();
+
+  const lockFile = lockPath(opts.pluginsDir);
+  const lock = readLock(lockFile);
+
+  const inLock = name in lock.plugins;
+  // Locate the plugin via its recorded origin (nested for remote sources). An
+  // orphan that is on disk but absent from the lock falls back to the flat path.
+  const dir = inLock
+    ? pluginDir(opts.pluginsDir, name, lock.plugins[name]!.origin)
+    : join(opts.pluginsDir, name);
+  const onDisk = existsSync(dir);
+  if (!inLock && !onDisk) {
+    throw new Error(`plugin "${name}" is not installed in ${opts.pluginsDir}`);
+  }
+
+  if (!opts.force) {
+    const dependents = Object.entries(lock.plugins)
+      .filter(([n, e]) => n !== name && e.dependencies && name in e.dependencies)
+      .map(([n]) => n);
+    if (dependents.length > 0) {
+      throw new Error(
+        `cannot remove "${name}": required by ${dependents.join(", ")}. ` +
+          `Remove the dependents first or pass --force.`,
+      );
+    }
+  }
+
+  // Clean up Claude symlinks (created by `adg plugins link --target claude`) in
+  // both global and project scopes — but only ones that resolve back to this
+  // plugin's directory, so unrelated entries are never disturbed.
+  const target = resolve(dir);
+  const unlinked: string[] = [];
+  for (const dir of [claudeSkillsDir(true, cwd), claudeSkillsDir(false, cwd)]) {
+    const linkPath = join(dir, name);
+    if (isSymlinkTo(linkPath, target)) {
+      rmSync(linkPath);
+      unlinked.push(linkPath);
+    }
+  }
+
+  let removedDir: string | undefined;
+  if (onDisk) {
+    rmSync(dir, { recursive: true, force: true });
+    removedDir = dir;
+    // Drop the per-marketplace bucket if it became empty (nested remote layout).
+    pruneEmptyParent(dirname(dir), opts.pluginsDir);
+  }
+
+  const removedFromLock = removeEntry(lock, name);
+  if (removedFromLock) writeLock(lockFile, lock);
+
+  const marketFile = marketplacePath(opts.pluginsDir);
+  const market = readMarketplace(marketFile, basename(opts.pluginsDir));
+  const removedFromMarketplace = removeMarketplacePlugin(market, name);
+  if (removedFromMarketplace) writeMarketplace(marketFile, market);
+
+  // Uninstall from the agents so we don't leave them enabled, pointing at a
+  // now-deleted directory. Best-effort across all; missing CLIs are skipped.
+  let agents: AgentSyncResult[] | undefined;
+  if (opts.deactivate) {
+    const ctx = { pluginsDir: opts.pluginsDir, plugins: [name], scope: opts.scope ?? "project" };
+    agents = (opts.agents ?? resolveAgents()).map((a) => a.deactivate(ctx));
+  }
+
+  return { name, removedDir, unlinked, removedFromLock, removedFromMarketplace, agents };
+}
+
+/**
+ * Remove `parent` if it is an empty per-marketplace bucket below `pluginsDir`.
+ * Never touches `pluginsDir` itself (that would be the flat local layout).
+ */
+function pruneEmptyParent(parent: string, pluginsDir: string): void {
+  if (resolve(parent) === resolve(pluginsDir)) return;
+  try {
+    if (readdirSync(parent).length === 0) rmdirSync(parent);
+  } catch {
+    // bucket already gone or not readable — nothing to prune
+  }
+}
+
+export function isSymlinkTo(linkPath: string, target: string): boolean {
+  try {
+    if (!lstatSync(linkPath).isSymbolicLink()) return false;
+    // readlinkSync may return a path relative to the link's own directory; resolve
+    // it there (resolve ignores the base when the target is already absolute).
+    return resolve(dirname(linkPath), readlinkSync(linkPath)) === resolve(target);
+  } catch {
+    return false;
+  }
+}

package/src/commands/select-agents.ts

@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import type { AdapterTarget } from "../adapters/index.ts";
+import { allAgents, detectedAgents } from "../agents/index.ts";
+
+/**
+ * Interactively choose which AI agents to adapt an installed plugin for.
+ *
+ * Mirrors the skills install flow: detect the agents present on the machine,
+ * pre-select them, and let the user toggle. When nothing is detected we fall
+ * back to pre-selecting every target so a fresh setup still adapts for all.
+ *
+ * Callers should only reach this in an interactive TTY without an explicit
+ * `--target`; non-interactive paths stay flag-driven.
+ */
+export async function selectTargetsInteractive(): Promise<AdapterTarget[]> {
+  const agents = allAgents();
+  const detectedSet = new Set(detectedAgents().map((a) => a.id));
+  const initialValues = (detectedSet.size > 0 ? [...detectedSet] : agents.map((a) => a.id)) as AdapterTarget[];
+
+  if (detectedSet.size > 0) {
+    const names = agents.filter((a) => detectedSet.has(a.id)).map((a) => pc.cyan(a.displayName)).join(", ");
+    p.log.info(`Detected: ${names}`);
+  } else {
+    p.log.info(pc.dim("No agents detected locally — pre-selecting all."));
+  }
+
+  const selected = await p.multiselect({
+    message: `Which agents do you want to adapt for? ${pc.dim("(space to toggle)")}`,
+    options: agents.map((a) => ({
+      value: a.id as AdapterTarget,
+      label: a.displayName,
+      ...(detectedSet.has(a.id) ? { hint: "detected" } : {}),
+    })),
+    initialValues,
+    required: true,
+  });
+
+  if (p.isCancel(selected)) {
+    p.cancel("Installation cancelled");
+    process.exit(0);
+  }
+
+  return selected as AdapterTarget[];
+}