@rbbtsn0w/adg 0.1.0-alpha.1 → 0.1.0-beta.2

package/src/commands/marketplace.ts

@@ -1,198 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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[];
-}

package/src/commands/select-components.ts

@@ -1,66 +0,0 @@
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import type { SelectComponentsRequest } from "./install.ts";
-import type { ComponentType, PluginSelection } from "../types.ts";
-import { multiselectSkills } from "./multiselect-skills.ts";
-
-function cancelled<T>(value: T | symbol): value is symbol {
-  if (p.isCancel(value)) {
-    p.cancel("Installation cancelled");
-    process.exit(0);
-  }
-  return false;
-}
-
-/**
- * The "install everything?" gate. Returns true to install each selected plugin
- * in full, false to drop into per-plugin component selection. Used by `add` in
- * an interactive terminal when no --only/--skill flags were given.
- */
-export async function confirmFullInstall(plugins: string[]): Promise<boolean> {
-  const list = plugins.length === 1 ? plugins[0] : `${plugins.length} plugins`;
-  const choice = await p.select({
-    message: `Install everything in ${pc.cyan(list)}?`,
-    options: [
-      { value: true, label: "Yes, install all", hint: "every skill, command, agent, mcp…" },
-      { value: false, label: "No, let me choose", hint: "pick components per plugin" },
-    ],
-    initialValue: true,
-  });
-  if (cancelled(choice)) return true;
-  return choice as boolean;
-}
-
-/**
- * Per-plugin component picker (①). Choose which categories to expose; if skills
- * is kept and the plugin has several, drill in to pick individual skills. Files
- * are still installed in full — this only narrows what the runtime sees.
- */
-export async function selectComponentsInteractive(req: SelectComponentsRequest): Promise<PluginSelection> {
-  const components = await p.multiselect({
-    message: `${pc.bold(req.name)} — what to install? ${pc.dim("(space to toggle)")}`,
-    options: req.present.map((c) => ({ value: c, label: `${c} (${req.contents[c].length})` })),
-    initialValues: [...req.present],
-    required: true,
-  });
-  if (cancelled(components)) return { components: [...req.present] };
-  const chosen = components as ComponentType[];
-
-  const selection: PluginSelection = { components: chosen };
-
-  // Drill into individual skills only when skills is kept and there's a choice.
-  if (chosen.includes("skills") && req.contents.skills.length > 1) {
-    const message = `${pc.bold(req.name)} — which skills? ${pc.dim("(space to toggle)")}`;
-    const options = req.contents.skills.map((s) => ({ value: s, label: s }));
-    const initialValues = [...req.contents.skills];
-    const skills = req.skillDescription
-      ? await multiselectSkills({ message, options, initialValues, loadDescription: req.skillDescription })
-      : await p.multiselect({ message, options, initialValues, required: true });
-    if (!cancelled(skills)) {
-      const picked = skills as string[];
-      if (picked.length !== req.contents.skills.length) selection.skills = picked;
-    }
-  }
-
-  return selection;
-}