@aipper/aiws 0.0.48 → 0.0.50

package/dist/lib/pi-plugins-doctor.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Pi user-level plugins doctor (TOOLING-002L / PB-010 / pi-plugin-doctor).
+ * Pure classify + format; I/O helpers injectable for tests.
+ */
+export type PluginTier = "required" | "recommended_a" | "recommended_b" | "forbidden";
+export interface ManifestPlugin {
+    id: string;
+    package: string;
+    version?: string;
+    tier?: PluginTier | string;
+    severity?: "conflict" | "forbidden" | string;
+    reason?: string;
+}
+export interface PiPluginsManifest {
+    version: number;
+    scope: string;
+    source_protocol: string;
+    install_template: string;
+    required: ManifestPlugin[];
+    recommended_a: ManifestPlugin[];
+    recommended_b: ManifestPlugin[];
+    forbidden: ManifestPlugin[];
+}
+export interface InstalledPackage {
+    /** bare or scoped name without version */
+    name: string;
+    version?: string;
+    raw?: string;
+}
+export type DetectSource = "pi_list" | "settings" | "none" | "injected";
+export interface DoctorClassifyInput {
+    manifest: PiPluginsManifest;
+    installed: InstalledPackage[];
+    piCliAvailable: boolean;
+    detectSource: DetectSource;
+}
+export interface DoctorFinding {
+    package: string;
+    version?: string;
+    tier: string;
+    kind: "missing_required" | "missing_recommended" | "conflict" | "forbidden_present" | "ok_required";
+    installCmd?: string;
+    reason?: string;
+}
+export interface DoctorReport {
+    piCliAvailable: boolean;
+    detectSource: DetectSource;
+    installedNames: string[];
+    missingRequired: DoctorFinding[];
+    missingRecommendedA: DoctorFinding[];
+    missingRecommendedB: DoctorFinding[];
+    conflicts: DoctorFinding[];
+    forbiddenPresent: DoctorFinding[];
+    okRequired: DoctorFinding[];
+    /** true when required all present and no conflicts */
+    ok: boolean;
+    /** CLI doctor exit should be non-zero when !ok or pi missing for strict mode */
+    exitCode: number;
+}
+export declare const DEFAULT_MANIFEST: PiPluginsManifest;
+/** Normalize package name for set membership (lowercase, strip version suffix). */
+export declare function normalizePackageName(raw: string): string;
+export declare function installCommandFor(plugin: ManifestPlugin, template?: string): string;
+/**
+ * Loose parse of `pi list` / package listing text.
+ * Accepts lines like:
+ * - @tintinweb/pi-subagents@0.14.2
+ * - npm:@tintinweb/pi-subagents@0.14.2
+ * - pi-powerbar 0.1.0
+ * - "name": "@tintinweb/pi-subagents"
+ * Skips URLs, filesystem paths, and section headers ("User packages:").
+ */
+export declare function parseInstalledFromText(text: string): InstalledPackage[];
+export declare function parseInstalledFromSettings(settingsJson: unknown): InstalledPackage[];
+/**
+ * Classify installed packages against manifest.
+ * Special case: forbidden id `pi-subagents` means unscoped only — do not match `@tintinweb/pi-subagents`.
+ */
+export declare function classifyPiPlugins(input: DoctorClassifyInput): DoctorReport;
+/**
+ * Unscoped `pi-subagents` must not match `@tintinweb/pi-subagents`.
+ * Presence of unscoped name alone is enough for conflict (even if tintinweb also installed).
+ */
+export declare function isForbiddenPresent(set: Set<string>, forbiddenPackage: string): boolean;
+export declare function formatDoctorReport(report: DoctorReport, opts?: {
+    header?: string;
+}): string;
+export declare function loadManifestFromSpec(): Promise<PiPluginsManifest>;
+export declare function normalizeManifest(data: Partial<PiPluginsManifest> | null | undefined): PiPluginsManifest;
+export declare function detectInstalledPackages(opts?: {
+    homeDir?: string;
+    runPiList?: () => Promise<{
+        ok: boolean;
+        text: string;
+    }>;
+}): Promise<{
+    installed: InstalledPackage[];
+    piCliAvailable: boolean;
+    detectSource: DetectSource;
+}>;
+export declare function runPiPluginsDoctor(opts?: {
+    homeDir?: string;
+    manifest?: PiPluginsManifest;
+    installed?: InstalledPackage[];
+    runPiList?: () => Promise<{
+        ok: boolean;
+        text: string;
+    }>;
+}): Promise<{
+    report: DoctorReport;
+    text: string;
+}>;
+/**
+ * Install required packages only (user scope). Never silent from callers without explicit flag.
+ */
+export declare function installRequiredPiPlugins(opts?: {
+    manifest?: PiPluginsManifest;
+    runInstall?: (args: string[]) => Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+}): Promise<{
+    attempted: string[];
+    results: Array<{
+        cmd: string;
+        code: number;
+        stderr: string;
+    }>;
+}>;

package/dist/lib/pi-plugins-doctor.js

@@ -0,0 +1,537 @@
+/**
+ * Pi user-level plugins doctor (TOOLING-002L / PB-010 / pi-plugin-doctor).
+ * Pure classify + format; I/O helpers injectable for tests.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { runCommand } from "../exec.js";
+import { pathExists, readText } from "../fs.js";
+export const DEFAULT_MANIFEST = {
+    version: 1,
+    scope: "user",
+    source_protocol: "npm:",
+    install_template: "pi install npm:{package}{versionSuffix}",
+    required: [
+        {
+            id: "@tintinweb/pi-subagents",
+            package: "@tintinweb/pi-subagents",
+            version: "0.14.2",
+            tier: "required",
+            reason: "Single approved Pi subagent runtime for AIWS force policy",
+        },
+    ],
+    recommended_a: [
+        { id: "pi-extension-settings", package: "pi-extension-settings", tier: "recommended_a" },
+        { id: "pi-powerbar", package: "pi-powerbar", tier: "recommended_a" },
+        { id: "pi-lsp", package: "pi-lsp", tier: "recommended_a" },
+        { id: "pi-hashline-edit-pro", package: "pi-hashline-edit-pro", tier: "recommended_a" },
+        { id: "rpiv-todo", package: "rpiv-todo", tier: "recommended_a" },
+        { id: "rpiv-ask-user-question", package: "rpiv-ask-user-question", tier: "recommended_a" },
+        { id: "pi-btw", package: "pi-btw", tier: "recommended_a" },
+        { id: "pi-caffeinate", package: "pi-caffeinate", tier: "recommended_a" },
+        { id: "pi-workspace-history", package: "pi-workspace-history", tier: "recommended_a" },
+    ],
+    recommended_b: [
+        { id: "pi-mcp-adapter", package: "pi-mcp-adapter", tier: "recommended_b" },
+        { id: "pi-fff", package: "pi-fff", tier: "recommended_b" },
+        { id: "pi-slopchop", package: "pi-slopchop", tier: "recommended_b" },
+        { id: "plan-mode", package: "plan-mode", tier: "recommended_b" },
+        { id: "pi-cache-optimizer", package: "pi-cache-optimizer", tier: "recommended_b" },
+        { id: "pi-rtk-optimizer", package: "pi-rtk-optimizer", tier: "recommended_b" },
+        { id: "pi-agent-browser-native", package: "pi-agent-browser-native", tier: "recommended_b" },
+        { id: "pi-add-dir", package: "pi-add-dir", tier: "recommended_b" },
+    ],
+    forbidden: [
+        {
+            id: "@narumitw/pi-subagents",
+            package: "@narumitw/pi-subagents",
+            severity: "conflict",
+            reason: "Second subagent runtime; exclusive with @tintinweb/pi-subagents",
+        },
+        {
+            id: "pi-subagents",
+            package: "pi-subagents",
+            severity: "conflict",
+            reason: "Unscoped/third-party subagents package; exclusive with @tintinweb/pi-subagents",
+        },
+        {
+            id: "@narumitw/pi-goal",
+            package: "@narumitw/pi-goal",
+            severity: "forbidden",
+            reason: "Dual goal orchestrator vs aiws goal",
+        },
+        {
+            id: "pi-autoresearch",
+            package: "pi-autoresearch",
+            severity: "forbidden",
+            reason: "Long main-write research loops under AIWS governance",
+        },
+    ],
+};
+/** Normalize package name for set membership (lowercase, strip version suffix). */
+export function normalizePackageName(raw) {
+    let s = raw.trim().replace(/^npm:/i, "");
+    // strip trailing @version for unscoped; keep scope for @scope/name@version
+    if (s.startsWith("@")) {
+        const at = s.lastIndexOf("@");
+        if (at > 0)
+            s = s.slice(0, at);
+    }
+    else {
+        const at = s.indexOf("@");
+        if (at > 0)
+            s = s.slice(0, at);
+    }
+    return s.toLowerCase();
+}
+export function installCommandFor(plugin, template) {
+    const t = template || DEFAULT_MANIFEST.install_template;
+    const versionSuffix = plugin.version ? `@${plugin.version}` : "";
+    return t.replace("{package}", plugin.package).replace("{versionSuffix}", versionSuffix);
+}
+const PARSE_SKIP_TOKENS = new Set([
+    "installed",
+    "packages",
+    "package",
+    "name",
+    "version",
+    "user",
+    "project",
+    "global",
+    "local",
+    "https",
+    "http",
+    "git",
+    "github",
+    "com",
+    "npm",
+]);
+/**
+ * Loose parse of `pi list` / package listing text.
+ * Accepts lines like:
+ * - @tintinweb/pi-subagents@0.14.2
+ * - npm:@tintinweb/pi-subagents@0.14.2
+ * - pi-powerbar 0.1.0
+ * - "name": "@tintinweb/pi-subagents"
+ * Skips URLs, filesystem paths, and section headers ("User packages:").
+ */
+export function parseInstalledFromText(text) {
+    const out = new Map();
+    const lines = text.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // git/http install lines: last path segment may be a package id
+        const gitUrl = trimmed.match(/^https?:\/\/[^\s]+\/([^/\s]+?)(?:\.git)?\/?\s*$/i);
+        if (gitUrl?.[1]) {
+            const name = normalizePackageName(gitUrl[1]);
+            if (name && !PARSE_SKIP_TOKENS.has(name) && (name.includes("-") || name.includes("_"))) {
+                out.set(name, { name, raw: trimmed });
+            }
+            continue;
+        }
+        if (/^https?:\/\//i.test(trimmed))
+            continue;
+        if (/^\/|^[A-Za-z]:[\\/]/.test(trimmed))
+            continue;
+        if (/packages?\s*:/i.test(trimmed) && !trimmed.includes("@") && !/^npm:/i.test(trimmed))
+            continue;
+        // JSON-ish "name": "pkg"
+        const jsonName = trimmed.match(/"name"\s*:\s*"(@?[^"]+)"/i);
+        if (jsonName?.[1]) {
+            const name = normalizePackageName(jsonName[1]);
+            if (name && !PARSE_SKIP_TOKENS.has(name))
+                out.set(name, { name, raw: trimmed });
+            continue;
+        }
+        // npm:pkg@version or pkg@version
+        const npmPref = trimmed.replace(/^npm:/i, "").trim();
+        const scoped = npmPref.match(/^(@[^/\s]+\/[^@\s]+)(?:@([^\s]+))?/);
+        if (scoped?.[1]) {
+            const name = normalizePackageName(scoped[1]);
+            out.set(name, { name, version: scoped[2], raw: trimmed });
+            continue;
+        }
+        const unscoped = npmPref.match(/^([a-z0-9][a-z0-9._-]{1,})(?:@([^\s]+))?$/i);
+        if (unscoped?.[1]) {
+            const name = normalizePackageName(unscoped[1]);
+            if (PARSE_SKIP_TOKENS.has(name))
+                continue;
+            if (!name.includes("-") && !name.includes("_") && name.length < 4)
+                continue;
+            out.set(name, { name, version: unscoped[2], raw: trimmed });
+        }
+    }
+    return Array.from(out.values());
+}
+export function parseInstalledFromSettings(settingsJson) {
+    const out = new Map();
+    if (!settingsJson || typeof settingsJson !== "object")
+        return [];
+    const obj = settingsJson;
+    const candidates = [];
+    for (const key of ["packages", "plugins", "extensions", "installed"]) {
+        if (key in obj)
+            candidates.push(obj[key]);
+    }
+    const addName = (raw, version) => {
+        const name = normalizePackageName(raw);
+        if (!name)
+            return;
+        out.set(name, { name, version, raw });
+    };
+    for (const c of candidates) {
+        if (Array.isArray(c)) {
+            for (const item of c) {
+                if (typeof item === "string")
+                    addName(item);
+                else if (item && typeof item === "object") {
+                    const rec = item;
+                    const n = String(rec.name || rec.package || rec.id || "").trim();
+                    if (n)
+                        addName(n, rec.version != null ? String(rec.version) : undefined);
+                }
+            }
+        }
+        else if (c && typeof c === "object") {
+            for (const [k, v] of Object.entries(c)) {
+                if (typeof v === "string")
+                    addName(k.includes("/") || k.startsWith("@") ? k : k, v);
+                else if (v && typeof v === "object") {
+                    const rec = v;
+                    const n = String(rec.name || rec.package || k).trim();
+                    addName(n, rec.version != null ? String(rec.version) : undefined);
+                }
+                else
+                    addName(k);
+            }
+        }
+    }
+    return Array.from(out.values());
+}
+function installedSet(installed) {
+    return new Set(installed.map((p) => normalizePackageName(p.name)));
+}
+function isPresent(set, pkg) {
+    return set.has(normalizePackageName(pkg));
+}
+/**
+ * Classify installed packages against manifest.
+ * Special case: forbidden id `pi-subagents` means unscoped only — do not match `@tintinweb/pi-subagents`.
+ */
+export function classifyPiPlugins(input) {
+    const { manifest, installed, piCliAvailable, detectSource } = input;
+    const set = installedSet(installed);
+    const names = Array.from(set).sort();
+    const missingRequired = [];
+    const okRequired = [];
+    for (const p of manifest.required || []) {
+        if (isPresent(set, p.package)) {
+            okRequired.push({
+                package: p.package,
+                version: p.version,
+                tier: "required",
+                kind: "ok_required",
+                reason: p.reason,
+            });
+        }
+        else {
+            missingRequired.push({
+                package: p.package,
+                version: p.version,
+                tier: "required",
+                kind: "missing_required",
+                installCmd: installCommandFor(p, manifest.install_template),
+                reason: p.reason,
+            });
+        }
+    }
+    const missingRecommendedA = [];
+    for (const p of manifest.recommended_a || []) {
+        if (!isPresent(set, p.package)) {
+            missingRecommendedA.push({
+                package: p.package,
+                version: p.version,
+                tier: "recommended_a",
+                kind: "missing_recommended",
+                installCmd: installCommandFor(p, manifest.install_template),
+            });
+        }
+    }
+    const missingRecommendedB = [];
+    for (const p of manifest.recommended_b || []) {
+        if (!isPresent(set, p.package)) {
+            missingRecommendedB.push({
+                package: p.package,
+                version: p.version,
+                tier: "recommended_b",
+                kind: "missing_recommended",
+                installCmd: installCommandFor(p, manifest.install_template),
+            });
+        }
+    }
+    const conflicts = [];
+    const forbiddenPresent = [];
+    for (const p of manifest.forbidden || []) {
+        const present = isForbiddenPresent(set, p.package);
+        if (!present)
+            continue;
+        const severity = p.severity === "forbidden" ? "forbidden" : "conflict";
+        const finding = {
+            package: p.package,
+            tier: "forbidden",
+            kind: severity === "forbidden" ? "forbidden_present" : "conflict",
+            reason: p.reason,
+        };
+        if (severity === "forbidden")
+            forbiddenPresent.push(finding);
+        else
+            conflicts.push(finding);
+    }
+    const hasBlockers = missingRequired.length > 0 || conflicts.length > 0 || forbiddenPresent.length > 0;
+    const ok = missingRequired.length === 0 && conflicts.length === 0 && forbiddenPresent.length === 0;
+    // doctor CLI: non-zero if missing required or conflicts/forbidden; pi missing alone is warn (exit 0) unless required also missing
+    let exitCode = 0;
+    if (hasBlockers)
+        exitCode = 1;
+    else if (!piCliAvailable && detectSource === "none")
+        exitCode = 0; // graceful
+    return {
+        piCliAvailable,
+        detectSource,
+        installedNames: names,
+        missingRequired,
+        missingRecommendedA,
+        missingRecommendedB,
+        conflicts,
+        forbiddenPresent,
+        okRequired,
+        ok,
+        exitCode,
+    };
+}
+/**
+ * Unscoped `pi-subagents` must not match `@tintinweb/pi-subagents`.
+ * Presence of unscoped name alone is enough for conflict (even if tintinweb also installed).
+ */
+export function isForbiddenPresent(set, forbiddenPackage) {
+    const n = normalizePackageName(forbiddenPackage);
+    if (n === "pi-subagents") {
+        return set.has("pi-subagents");
+    }
+    return set.has(n);
+}
+export function formatDoctorReport(report, opts) {
+    const lines = [];
+    lines.push(opts?.header ?? "aiws doctor: Pi user-level plugins");
+    lines.push(`detect: ${report.detectSource}${report.piCliAvailable ? " (pi cli ok)" : " (pi cli missing or unused)"}`);
+    lines.push(`installed: ${report.installedNames.length ? report.installedNames.join(", ") : "(none detected)"}`);
+    lines.push("");
+    if (!report.piCliAvailable && report.detectSource === "none") {
+        lines.push("warn: `pi` CLI not found and no ~/.pi/agent settings packages detected.");
+        lines.push("  Install Pi, then: pi install npm:@tintinweb/pi-subagents@0.14.2");
+        lines.push("");
+    }
+    if (report.missingRequired.length) {
+        lines.push("## missing required");
+        for (const f of report.missingRequired) {
+            lines.push(`- ${f.package}${f.version ? `@${f.version}` : ""}${f.reason ? ` — ${f.reason}` : ""}`);
+            if (f.installCmd)
+                lines.push(`  ${f.installCmd}`);
+        }
+        lines.push("");
+    }
+    else {
+        lines.push("## required: ok");
+        for (const f of report.okRequired) {
+            lines.push(`- ${f.package}${f.version ? ` (pin ${f.version})` : ""}`);
+        }
+        lines.push("");
+    }
+    if (report.conflicts.length) {
+        lines.push("## conflicts (remove or disable; keep only @tintinweb/pi-subagents)");
+        for (const f of report.conflicts) {
+            lines.push(`- ${f.package}${f.reason ? ` — ${f.reason}` : ""}`);
+        }
+        lines.push("");
+    }
+    if (report.forbiddenPresent.length) {
+        lines.push("## forbidden present (AIWS governance recommends removing)");
+        for (const f of report.forbiddenPresent) {
+            lines.push(`- ${f.package}${f.reason ? ` — ${f.reason}` : ""}`);
+        }
+        lines.push("");
+    }
+    if (report.missingRecommendedA.length) {
+        lines.push("## missing recommended (tier A) — optional");
+        for (const f of report.missingRecommendedA.slice(0, 20)) {
+            lines.push(`- ${f.installCmd || f.package}`);
+        }
+        lines.push("");
+    }
+    if (report.missingRecommendedB.length) {
+        lines.push("## missing recommended (tier B) — on demand");
+        for (const f of report.missingRecommendedB.slice(0, 20)) {
+            lines.push(`- ${f.installCmd || f.package}`);
+        }
+        lines.push("");
+    }
+    lines.push(report.ok
+        ? "status: ok (required present, no conflicts)"
+        : "status: action needed (see missing required / conflicts)");
+    lines.push("note: default is detect+prompt only; use `aiws doctor --install-pi-plugins` to install required (user scope).");
+    return lines.join("\n");
+}
+export async function loadManifestFromSpec() {
+    try {
+        const require = createRequire(import.meta.url);
+        let rootDir = null;
+        try {
+            const pkgJsonPath = require.resolve("@aipper/aiws-spec/package.json");
+            rootDir = path.dirname(pkgJsonPath);
+        }
+        catch {
+            const here = fileURLToPath(import.meta.url);
+            rootDir = path.resolve(path.dirname(here), "../../../spec");
+        }
+        const jsonPath = path.join(rootDir, "docs", "pi-plugins-manifest.json");
+        if (await pathExists(jsonPath)) {
+            const data = JSON.parse(await readText(jsonPath));
+            return normalizeManifest(data);
+        }
+    }
+    catch {
+        // fall through
+    }
+    return DEFAULT_MANIFEST;
+}
+export function normalizeManifest(data) {
+    const base = DEFAULT_MANIFEST;
+    if (!data || typeof data !== "object")
+        return base;
+    return {
+        version: typeof data.version === "number" ? data.version : base.version,
+        scope: String(data.scope || base.scope),
+        source_protocol: String(data.source_protocol || base.source_protocol),
+        install_template: String(data.install_template || base.install_template),
+        required: Array.isArray(data.required) ? data.required : base.required,
+        recommended_a: Array.isArray(data.recommended_a) ? data.recommended_a : base.recommended_a,
+        recommended_b: Array.isArray(data.recommended_b) ? data.recommended_b : base.recommended_b,
+        forbidden: Array.isArray(data.forbidden) ? data.forbidden : base.forbidden,
+    };
+}
+export async function detectInstalledPackages(opts) {
+    const home = opts?.homeDir ?? os.homedir();
+    const runPiList = opts?.runPiList ??
+        (async () => {
+            try {
+                const r = await runCommand("pi", ["list"]);
+                if (r.code === 0 || r.stdout.trim()) {
+                    return { ok: true, text: `${r.stdout}\n${r.stderr}` };
+                }
+                return { ok: false, text: `${r.stdout}\n${r.stderr}` };
+            }
+            catch {
+                return { ok: false, text: "" };
+            }
+        });
+    const pi = await runPiList();
+    if (pi.ok && pi.text.trim()) {
+        const installed = parseInstalledFromText(pi.text);
+        if (installed.length > 0) {
+            return { installed, piCliAvailable: true, detectSource: "pi_list" };
+        }
+        // pi exists but empty list
+        return { installed: [], piCliAvailable: true, detectSource: "pi_list" };
+    }
+    // settings fallback
+    const settingsPath = path.join(home, ".pi", "agent", "settings.json");
+    try {
+        if (await pathExists(settingsPath)) {
+            const json = JSON.parse(await readText(settingsPath));
+            const installed = parseInstalledFromSettings(json);
+            // also scan packages dir names
+            const pkgDir = path.join(home, ".pi", "agent", "packages");
+            if (await pathExists(pkgDir)) {
+                const ents = await fs.readdir(pkgDir).catch(() => []);
+                for (const e of ents) {
+                    const name = normalizePackageName(e.replace(/@/g, "/").replace(/^npm_/, ""));
+                    // directory names are messy; also try reading package.json name
+                    const pj = path.join(pkgDir, e, "package.json");
+                    if (await pathExists(pj)) {
+                        try {
+                            const meta = JSON.parse(await readText(pj));
+                            if (meta?.name) {
+                                installed.push({ name: normalizePackageName(String(meta.name)), version: meta.version ? String(meta.version) : undefined });
+                            }
+                        }
+                        catch {
+                            if (name)
+                                installed.push({ name });
+                        }
+                    }
+                }
+            }
+            const dedup = new Map(installed.map((p) => [normalizePackageName(p.name), p]));
+            return {
+                installed: Array.from(dedup.values()),
+                piCliAvailable: false,
+                detectSource: "settings",
+            };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { installed: [], piCliAvailable: false, detectSource: "none" };
+}
+export async function runPiPluginsDoctor(opts) {
+    const manifest = opts?.manifest ?? (await loadManifestFromSpec());
+    let installed = opts?.installed;
+    let piCliAvailable = true;
+    let detectSource = "injected";
+    if (!installed) {
+        const det = await detectInstalledPackages({ homeDir: opts?.homeDir, runPiList: opts?.runPiList });
+        installed = det.installed;
+        piCliAvailable = det.piCliAvailable;
+        detectSource = det.detectSource;
+    }
+    const report = classifyPiPlugins({
+        manifest,
+        installed,
+        piCliAvailable,
+        detectSource,
+    });
+    return { report, text: formatDoctorReport(report) };
+}
+/**
+ * Install required packages only (user scope). Never silent from callers without explicit flag.
+ */
+export async function installRequiredPiPlugins(opts) {
+    const manifest = opts?.manifest ?? (await loadManifestFromSpec());
+    const runInstall = opts?.runInstall ??
+        (async (args) => {
+            try {
+                return await runCommand("pi", args);
+            }
+            catch (e) {
+                return { code: 1, stdout: "", stderr: e instanceof Error ? e.message : String(e) };
+            }
+        });
+    const attempted = [];
+    const results = [];
+    for (const p of manifest.required || []) {
+        const versionSuffix = p.version ? `@${p.version}` : "";
+        const npmSpec = `npm:${p.package}${versionSuffix}`;
+        const cmd = `pi install ${npmSpec}`;
+        attempted.push(cmd);
+        const r = await runInstall(["install", npmSpec]);
+        results.push({ cmd, code: r.code, stderr: r.stderr });
+    }
+    return { attempted, results };
+}
+//# sourceMappingURL=pi-plugins-doctor.js.map