auriga-cli 1.7.0 → 1.9.2

package/dist/guide.js

@@ -0,0 +1,120 @@
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+function c(color, code, text) {
+    return color ? `${code}${text}${RESET}` : text;
+}
+/**
+ * Renders the Agent-bootstrap SOP per spec §3.6. Plain-text when
+ * `color: false`; adds ANSI escapes for headings / command examples
+ * / warnings when `color: true`. Color detection happens at the call
+ * site (`process.stdout.isTTY && !process.env.NO_COLOR`); this
+ * function just renders what it's told.
+ */
+export function renderGuide(opts) {
+    const h = (s) => c(opts.color, BOLD + CYAN, s);
+    const cmd = (s) => c(opts.color, DIM, s);
+    const warn = (s) => c(opts.color, YELLOW, s);
+    return `${h(`# auriga-cli bootstrap SOP (v${opts.version})`)}
+
+This guide walks an Agent through installing the auriga harness
+(CLAUDE.md + skills + plugins + hooks) into the current repository.
+
+Run each step in order. If any step fails with exit 1, stop and report.
+If exit 2, see stderr for per-category status and follow the "Retry"
+hint.
+
+${h("## Step 1 — Prerequisite check")}
+
+Ensure these CLIs are in PATH:
+  - node   (>= 18)
+  - git
+  - claude (required for plugins; see https://docs.claude.com/claude-code)
+
+Optional (only if you'll push a PR): gh
+
+Verify:
+  ${cmd("node --version && git --version && claude --version")}
+
+If \`claude\` is missing: install Claude Code first, then re-run this guide.
+
+${h("## Step 2 — Read --help BEFORE installing (do not skip)")}
+
+${warn("⚠")} Always inspect the catalog first so you know which skills,
+plugins, and hooks are actually relevant for this project. Blindly
+running \`install --all\` works as a turnkey preset, but for anything
+beyond a greenfield bootstrap you should narrow scope.
+
+Top-level catalog (every workflow skill / recommended skill / plugin /
+hook with a short description):
+  ${cmd("npx -y auriga-cli --help")}
+
+Per-type detail (flags + only that category's catalog slice):
+  ${cmd("npx -y auriga-cli install workflow --help")}
+  ${cmd("npx -y auriga-cli install skills --help")}
+  ${cmd("npx -y auriga-cli install recommended --help")}
+  ${cmd("npx -y auriga-cli install plugins --help")}
+  ${cmd("npx -y auriga-cli install hooks --help")}
+
+${h("## Step 3 — Install")}
+
+Preset — the full default-on set (workflow + skills + plugins + hooks;
+recommended skills are NOT included):
+  ${cmd("npx -y auriga-cli install --all")}
+
+Targeted — single category, picking from the catalog surfaced in Step 2:
+  ${cmd("npx -y auriga-cli install workflow --lang en")}
+  ${cmd("npx -y auriga-cli install skills --skill brainstorming test-driven-development")}
+  ${cmd("npx -y auriga-cli install plugins --plugin skill-creator codex --scope user")}
+  ${cmd("npx -y auriga-cli install hooks --hook pr-ready-guard")}
+
+Opt-in hooks: some hooks (e.g. \`notify\`) are NOT in the default set
+because they have side effects (OS notifications, platform-gated deps).
+Name them explicitly to install:
+  ${cmd("npx -y auriga-cli install hooks --hook notify")}
+
+Opt-in recommended skills (cross-model delegation helpers —
+claude-code-agent, codex-agent):
+  ${cmd("npx -y auriga-cli install recommended")}
+
+(The leading \`-y\` is npx's flag; it suppresses the "is it OK to install
+this package?" prompt. Required for non-interactive sessions.)
+
+Exit codes:
+  0  — all requested categories installed
+  1  — fatal error (parse / fetch / missing prerequisite). Read stderr;
+       fix the root cause and re-run the SAME command.
+  2  — partial success. stderr lists per-category status. Retry only the
+       failed category (the retry line is printed verbatim on stderr).
+
+${h("## Step 4 — Reload session (REQUIRED when installed non-interactively)")}
+
+${warn("⚠")} CLAUDE.md, .agents/skills/, .claude/plugins.json, and hook
+registrations are loaded at Claude Code session startup. If you ran
+\`npx -y auriga-cli install\` inside an existing Claude Code session
+(e.g., \`claude -p\` / \`claude -p --worktree\`), the current session
+will NOT see the new harness.
+
+Action:
+  - Commit any in-flight work first
+  - Exit this session and start a new one to pick up the harness
+  - Resume the original task in the new session
+
+${h("## Step 5 — Verify install")}
+
+Expected artifacts:
+  - CLAUDE.md                 (workflow manifesto)
+  - AGENTS.md -> CLAUDE.md    (symlink)
+  - .agents/skills/<name>/    (one per installed skill)
+  - .claude/plugins.json
+  - .claude/settings.json     (updated hook registrations, if hooks selected)
+
+${h("## Troubleshooting")}
+
+- Network error during fetch → retry; if persistent, check GitHub raw access
+- "catalog missing" error → re-install the package (\`npx clear-npx-cache\`)
+- \`claude plugins install\` hangs → abort, report; see known issue list
+`;
+}

package/dist/help.d.ts

@@ -0,0 +1,14 @@
+import type { Catalog } from "./catalog.js";
+import type { CategoryName } from "./types.js";
+/**
+ * Renders the detailed `--help` output per spec §4. Agent-readable
+ * catalog of every installable: Agent can decide what to pass to
+ * `install <type>` without a second round-trip.
+ */
+export declare function renderHelp(catalog: Catalog, version: string): string;
+/**
+ * Per-type help (`install <type> --help`). Shows just the flags and
+ * the matching catalog slice so an Agent can make a precise pick
+ * without scrolling past unrelated categories.
+ */
+export declare function renderTypeHelp(catalog: Catalog, type: CategoryName, version: string): string;

package/dist/help.js

@@ -0,0 +1,152 @@
+/**
+ * Renders the detailed `--help` output per spec §4. Agent-readable
+ * catalog of every installable: Agent can decide what to pass to
+ * `install <type>` without a second round-trip.
+ */
+export function renderHelp(catalog, version) {
+    const col = (entries) => entries.map((e) => `  ${padRight(e.name, 30)} ${truncate(e.description, 50)}`).join("\n");
+    return `auriga-cli v${version} — install Claude Code harness modules
+
+USAGE
+  npx auriga-cli guide                                   Agent bootstrap SOP (start here)
+  npx auriga-cli install                                 (TTY only) checkbox menu
+  npx auriga-cli install --all [--scope <s>]             workflow + skills + plugins + hooks
+                                                         (excludes recommended — install separately)
+  npx auriga-cli install <type> [type-specific flags]    single category
+  npx auriga-cli install <type> --help                   per-category help + catalog subset
+  npx auriga-cli --help
+
+  For non-interactive (Agent) use, prepend npx's own -y flag:
+    npx -y auriga-cli guide
+    npx -y auriga-cli install --all
+
+TYPES (exactly one with <type> form)
+  workflow       CLAUDE.md + AGENTS.md (workflow manifesto)
+  skills         Default-on workflow skills (listed below)
+  recommended    Opt-in utility skills (listed below)
+  plugins        Claude Code plugins (listed below)
+  hooks          Project-level hooks for Claude Code (listed below)
+
+TYPE-SPECIFIC FLAGS
+  workflow:       --lang <code>                  default en; available: en, zh-CN
+                  --cwd <dir>                    default current working directory
+  skills:         --skill <names...>             space-separated; '*' = all
+                  --scope <project|user>         default project
+  recommended:    --recommended-skill <names...>
+                  --scope <project|user>         default project
+  plugins:        --plugin <names...>
+                  --scope <project|user>         default project
+  hooks:          --hook <names...>              non-interactive default installs every
+                                                 hook with defaultOn != false
+                  --scope <project|user>         default project
+
+TOP-LEVEL OPTIONS
+  -h, --help                     show this help
+  -v, --version                  show version
+
+──────────────────────────────────────────────────────
+CATALOG (what each category contains)
+──────────────────────────────────────────────────────
+
+Workflow skills (category: skills)  ← installed by --all
+${col(catalog.workflowSkills)}
+
+Recommended skills (category: recommended)  ← NOT installed by --all
+${col(catalog.recommendedSkills)}
+
+Plugins (category: plugins)
+${col(catalog.plugins)}
+
+Hooks (category: hooks)
+${col(catalog.hooks)}
+
+More: https://github.com/Ben2pc/auriga-cli
+`;
+}
+/**
+ * Per-type help (`install <type> --help`). Shows just the flags and
+ * the matching catalog slice so an Agent can make a precise pick
+ * without scrolling past unrelated categories.
+ */
+export function renderTypeHelp(catalog, type, version) {
+    const col = (entries) => entries.map((e) => `  ${padRight(e.name, 30)} ${truncate(e.description, 50)}`).join("\n");
+    const header = `auriga-cli v${version} — install ${type}`;
+    switch (type) {
+        case "workflow":
+            return `${header}
+
+USAGE
+  npx auriga-cli install workflow [--lang <code>] [--cwd <dir>]
+
+FLAGS
+  --lang <code>   default en; available: en, zh-CN
+  --cwd <dir>     default current working directory
+
+NOTE
+  workflow has no --scope flag (single file + AGENTS.md symlink).
+`;
+        case "skills":
+            return `${header}
+
+USAGE
+  npx auriga-cli install skills [--skill <names...>] [--scope <project|user>]
+
+FLAGS
+  --skill <names...>       space-separated; '*' = all
+                           omit → install every workflow skill listed below
+  --scope <project|user>   default project
+
+CATALOG (workflow skills — default-on set)
+${col(catalog.workflowSkills)}
+`;
+        case "recommended":
+            return `${header}
+
+USAGE
+  npx auriga-cli install recommended [--recommended-skill <names...>] [--scope <project|user>]
+
+FLAGS
+  --recommended-skill <names...>   space-separated; '*' = all
+                                   omit → install every recommended skill listed below
+  --scope <project|user>           default project
+
+CATALOG (recommended skills — opt-in, NOT installed by --all)
+${col(catalog.recommendedSkills)}
+`;
+        case "plugins":
+            return `${header}
+
+USAGE
+  npx auriga-cli install plugins [--plugin <names...>] [--scope <project|user>]
+
+FLAGS
+  --plugin <names...>      space-separated; '*' = all
+                           omit → install every plugin listed below
+  --scope <project|user>   default project
+
+CATALOG (plugins)
+${col(catalog.plugins)}
+`;
+        case "hooks":
+            return `${header}
+
+USAGE
+  npx auriga-cli install hooks [--hook <names...>] [--scope <project|user>]
+
+FLAGS
+  --hook <names...>        space-separated; '*' = every compatible hook
+                           omit → install every hook with defaultOn != false
+  --scope <project|user>   default project
+                           (project-local is only reachable via the TTY menu)
+
+CATALOG (hooks — entries flagged "(opt-in)" require explicit --hook)
+${col(catalog.hooks)}
+`;
+    }
+}
+function padRight(s, width) {
+    return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function truncate(s, width) {
+    return s.length <= width ? s : s.slice(0, width - 1) + "…";
+}

package/dist/hooks.d.ts

@@ -1,3 +1,4 @@
+import { type InstallOpts } from "./utils.js";
 export interface HookDep {
     name: string;
     via: "brew";
@@ -34,6 +35,15 @@ export interface HookDef {
      * back to a generic "see <dir>/README.md" pointer.
      */
     customizeHints?: string[];
+    /**
+     * Whether the hook is part of the default-on set. `false` makes the
+     * hook opt-in: non-interactive `install hooks` with no `--hook` filter
+     * skips it, and the interactive checkbox leaves it unchecked. Absent
+     * / `true` → installed by default. Used for hooks with intrusive
+     * side effects (OS notifications, brew deps, platform constraints)
+     * that users probably want to pick up consciously.
+     */
+    defaultOn?: boolean;
 }
 export interface HooksConfig {
     hooks: HookDef[];
@@ -108,6 +118,19 @@ export declare function removeHookFromSettings(settings: SettingsFile, marker: s
     removed: number;
 };
 type Scope = "project-local" | "project" | "user";
+/**
+ * Non-interactive scope map for hooks.
+ *
+ * Non-interactive surface only knows about two values — `project` (the
+ * default) and `user`. `project-local` exists only in the TTY menu; it's
+ * a per-developer uncommitted scope and carries enough "did you really
+ * mean this?" surface area that we gate it behind an interactive
+ * confirmation rather than exposing it as a CLI flag value.
+ *
+ * Exported so `tests/hooks.test.ts` can lock the contract down as a
+ * unit test.
+ */
+export declare function mapNonInteractiveScope(scope: string | undefined): Scope;
 export declare function depBinary(dep: HookDep): string;
 export declare function loadHooksConfig(packageRoot: string): HooksConfig;
 export interface InstallHookResult {
@@ -158,5 +181,26 @@ export declare function cleanHookFromScope(hook: HookDef, scope: Scope, projectB
     removed: number;
     settingsPath: string;
 };
-export declare function installHooks(packageRoot: string): Promise<void>;
+/**
+ * Non-interactive selection resolver for hooks.
+ *
+ * Diverges from resolvePluginSelection in the no-filter case. Hooks can
+ * carry intrusive side effects (OS notifications, brew deps), so the
+ * safe default is NOT "install everything". Three cases:
+ *
+ * - undefined (no --hook passed) → default-on set (filter on defaultOn !== false)
+ * - ["*"] (explicit opt-in to everything) → full compatible set
+ * - explicit names → exactly those (even if defaultOn is false)
+ */
+export declare function resolveHookSelection(compatible: HookDef[], selected: string[] | undefined): HookDef[];
+/**
+ * Given the full registry and the platform-filtered compatible subset,
+ * return the names in `selected` that refer to real hooks but aren't
+ * available on the current platform. Empty result means the selection
+ * is either fully compatible or references unknown hooks (that case is
+ * left to the catalog validator — we don't pretend unknown names are
+ * platform issues).
+ */
+export declare function findIncompatibleExplicit(all: HookDef[], compatible: HookDef[], selected: string[]): string[];
+export declare function installHooks(packageRoot: string, opts: InstallOpts): Promise<void>;
 export {};

package/dist/hooks.js

@@ -148,6 +148,9 @@ function validateHookEntry(hook, idx) {
             }
         }
     }
+    if (h.defaultOn !== undefined && typeof h.defaultOn !== "boolean") {
+        throw new Error(`hooks.json: hooks[${idx}].defaultOn must be a boolean`);
+    }
 }
 /**
  * Pure, idempotent settings merge. Deep-clones input, dedupes by two
@@ -313,6 +316,21 @@ function resolveScope(scope, projectBase, hookName) {
         commandHookDir: `$CLAUDE_PROJECT_DIR/.claude/hooks/${hookName}`,
     };
 }
+/**
+ * Non-interactive scope map for hooks.
+ *
+ * Non-interactive surface only knows about two values — `project` (the
+ * default) and `user`. `project-local` exists only in the TTY menu; it's
+ * a per-developer uncommitted scope and carries enough "did you really
+ * mean this?" surface area that we gate it behind an interactive
+ * confirmation rather than exposing it as a CLI flag value.
+ *
+ * Exported so `tests/hooks.test.ts` can lock the contract down as a
+ * unit test.
+ */
+export function mapNonInteractiveScope(scope) {
+    return scope === "user" ? "user" : "project";
+}
 function scopeChoices() {
     return [
         {
@@ -659,35 +677,100 @@ export function cleanHookFromScope(hook, scope, projectBase) {
     }
     return { removed: result.removed, settingsPath: r.settingsPath };
 }
-export async function installHooks(packageRoot) {
+/**
+ * Non-interactive selection resolver for hooks.
+ *
+ * Diverges from resolvePluginSelection in the no-filter case. Hooks can
+ * carry intrusive side effects (OS notifications, brew deps), so the
+ * safe default is NOT "install everything". Three cases:
+ *
+ * - undefined (no --hook passed) → default-on set (filter on defaultOn !== false)
+ * - ["*"] (explicit opt-in to everything) → full compatible set
+ * - explicit names → exactly those (even if defaultOn is false)
+ */
+export function resolveHookSelection(compatible, selected) {
+    if (!selected)
+        return compatible.filter((h) => h.defaultOn !== false);
+    if (selected.length === 1 && selected[0] === "*")
+        return compatible;
+    const wanted = new Set(selected);
+    return compatible.filter((h) => wanted.has(h.name));
+}
+/**
+ * Given the full registry and the platform-filtered compatible subset,
+ * return the names in `selected` that refer to real hooks but aren't
+ * available on the current platform. Empty result means the selection
+ * is either fully compatible or references unknown hooks (that case is
+ * left to the catalog validator — we don't pretend unknown names are
+ * platform issues).
+ */
+export function findIncompatibleExplicit(all, compatible, selected) {
+    const compatibleNames = new Set(compatible.map((h) => h.name));
+    const allNames = new Set(all.map((h) => h.name));
+    return selected.filter((n) => allNames.has(n) && !compatibleNames.has(n));
+}
+export async function installHooks(packageRoot, opts) {
     const config = loadHooksConfig(packageRoot);
     const compatible = config.hooks.filter((h) => h.runtimePlatforms.includes(process.platform));
     if (compatible.length === 0) {
         log.warn(`No hooks available for your platform (${process.platform}). Skipping.`);
         return;
     }
-    const selected = await withEsc(checkbox({
-        message: "Select hooks to install:",
-        choices: compatible.map((h) => ({
-            name: `${h.name} — ${h.description}`,
-            value: h,
-            checked: true,
-        })),
-    }));
+    // Non-interactive explicit `--hook <name>` has stronger intent than
+    // the default set: if the caller named a hook that isn't available
+    // on this platform, fail fast. A silent no-op would let CI pipelines
+    // report success with the intended hook missing.
+    if (!opts.interactive && opts.selected && opts.selected[0] !== "*") {
+        const missing = findIncompatibleExplicit(config.hooks, compatible, opts.selected);
+        if (missing.length > 0) {
+            throw new Error(`hook${missing.length > 1 ? "s" : ""} not available on ${process.platform}: ${missing.join(", ")}. Run \`npx -y auriga-cli install hooks --help\` to see platform compatibility.`);
+        }
+    }
+    const selected = opts.interactive
+        ? await withEsc(checkbox({
+            message: "Select hooks to install:",
+            choices: compatible.map((h) => ({
+                name: `${h.name} — ${h.description}`,
+                value: h,
+                checked: h.defaultOn !== false,
+            })),
+        }))
+        : resolveHookSelection(compatible, opts.selected);
+    // Surface any opt-in hooks skipped by the default set so the user
+    // isn't silently missing a hook they can see in --help / the README.
+    // Only fires on the non-interactive undefined-selection path (TTY
+    // checkbox already shows them unchecked).
+    if (!opts.interactive && opts.selected === undefined) {
+        const skippedOptIn = compatible.filter((h) => h.defaultOn === false);
+        for (const h of skippedOptIn) {
+            log.skip(`${h.name} (opt-in; re-run \`npx -y auriga-cli install hooks --hook ${h.name}\` to install)`);
+        }
+    }
     if (selected.length === 0) {
         log.skip("No hooks selected");
         return;
     }
+    // Non-interactive scope (two values only):
+    //   undefined / "project" → project (shared .claude/settings.json)
+    //   "user"                → user    (~/.claude/settings.json)
+    // project-local is reachable only via the TTY menu.
+    const nonInteractiveScope = mapNonInteractiveScope(opts.scope);
     // Lazily prompted on the first project-scoped hook, then reused. Users
     // who pick only "user" scope are never asked about a project directory.
+    //
+    // Non-interactive path always falls back to `process.cwd()` — the
+    // parser rejects `--cwd` for any non-workflow type (§3.5 rule 5), so
+    // reading `opts.cwd` here would just be dead dispatch.
     let projectBaseResolved = null;
     async function ensureProjectBase() {
         if (projectBaseResolved !== null)
             return projectBaseResolved;
-        const projectBase = await withEsc(input({
-            message: "Hooks install target directory:",
-            default: process.cwd(),
-        }));
+        const projectBase = opts.interactive
+            ? await withEsc(input({
+                message: "Hooks install target directory:",
+                default: process.cwd(),
+            }))
+            : process.cwd();
         const resolvedPath = path.resolve(projectBase);
         if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) {
             log.error(`Not a valid directory: ${resolvedPath}`);
@@ -696,22 +779,27 @@ export async function installHooks(packageRoot) {
         projectBaseResolved = resolvedPath;
         return projectBaseResolved;
     }
+    const failures = [];
     for (const hook of selected) {
         console.log(`\n· ${hook.name}`);
         // Per-hook scope is intentional (not a single upfront prompt like
         // plugins.ts / skills.ts): a future user may want personal dev tools
         // at user level and project-specific hooks at project level. The
         // single-hook case is functionally identical to a single prompt.
-        const scope = await withEsc(select({
-            message: `Where to install the ${hook.name} hook?`,
-            choices: scopeChoices(),
-            default: "project-local",
-        }));
+        const scope = opts.interactive
+            ? await withEsc(select({
+                message: `Where to install the ${hook.name} hook?`,
+                choices: scopeChoices(),
+                default: "project-local",
+            }))
+            : nonInteractiveScope;
         // User scope mutates ~/.claude/settings.json — global, affects every
         // project on this machine. A passive select label and a one-line warn
         // both scroll past quickly. Make the user explicitly opt in to the
         // global mutation; default to "no" so a missed Enter is the safe path.
-        if (scope === "user") {
+        // In non-interactive mode the caller has already expressed intent via
+        // `--scope user`, so we honor it without another confirmation gate.
+        if (opts.interactive && scope === "user") {
             const proceed = await withEsc(confirm({
                 message: `Modify your global ~/.claude/settings.json? This affects every project on this machine. A .bak snapshot is taken before any change.`,
                 default: false,
@@ -732,13 +820,17 @@ export async function installHooks(packageRoot) {
         // Cross-scope cleanup: if this hook's marker is already present in a
         // *different* scope's settings file, leaving it there means the hook
         // will fire from both scopes. Detect, prompt, clean before installing.
+        // In non-interactive mode the default (remove stale) is applied
+        // silently — matches the interactive default: true.
         const stale = findStaleScopes(hook, scope, projectBaseForHook);
         for (const entry of stale) {
             log.warn(`Found existing ${hook.name} hook in ${relativeFromCwd(entry.settingsPath)} (${entry.scope} scope, ${entry.count} entr${entry.count === 1 ? "y" : "ies"})`);
-            const remove = await withEsc(confirm({
-                message: `Remove the stale registration so the hook only fires once?`,
-                default: true,
-            }));
+            const remove = opts.interactive
+                ? await withEsc(confirm({
+                    message: `Remove the stale registration so the hook only fires once?`,
+                    default: true,
+                }))
+                : true;
             if (remove) {
                 const cleaned = cleanHookFromScope(hook, entry.scope, projectBaseForHook);
                 log.ok(`removed ${cleaned.removed} from ${relativeFromCwd(cleaned.settingsPath)}`);
@@ -756,10 +848,12 @@ export async function installHooks(packageRoot) {
         }
         catch (e) {
             log.error(`${hook.name}: ${e.message}`);
+            failures.push(hook.name);
             continue;
         }
         if (result.aborted) {
             log.error(`${hook.name} aborted: ${result.aborted}`);
+            failures.push(hook.name);
             continue;
         }
         const settingsRel = relativeFromCwd(result.settingsPath);
@@ -771,6 +865,10 @@ export async function installHooks(packageRoot) {
         if (result.settingsError) {
             log.error(`${hook.name}: ${result.settingsError}`);
             log.warn(`Files were copied to ${dirRel} but settings not updated. Add the hook entry manually if you want it active.`);
+            // Registration failure leaves the hook installed-but-inactive. Count
+            // it as a failure so non-interactive `install hooks` exits 2 and the
+            // caller can retry — quietly reporting success would ship a dead hook.
+            failures.push(hook.name);
         }
         else if (result.settingsMutated) {
             log.ok(`registered in ${settingsRel}`);
@@ -792,4 +890,7 @@ export async function installHooks(packageRoot) {
             console.log(`  See ${dirRel}/README.md for customization options.`);
         }
     }
+    if (failures.length > 0 && !opts.interactive) {
+        throw new Error(`${failures.length} hook(s) failed to install: ${failures.join(", ")}`);
+    }
 }

package/dist/plugins.d.ts

@@ -1 +1,3 @@
-export declare function installPlugins(packageRoot: string): Promise<void>;
+import type { InstallOpts, PluginsConfig } from "./utils.js";
+export declare function validatePluginsConfig(raw: unknown): asserts raw is PluginsConfig;
+export declare function installPlugins(packageRoot: string, opts: InstallOpts): Promise<void>;