@gaosh3n/pi-package-manager 0.1.2 → 0.1.4

package/README.md

@@ -9,6 +9,7 @@
 - `/package-manager status` to see whether updates are available
 - `/package-manager update` to run the update flow on demand
 - `/package-manager install` to install a Pi package from an entered source
+- `/package-manager uninstall` to remove one or more installed Pi packages from a checkbox-style picker
 - a final result card in Pi so you can review the latest outcome
 - automatic Pi reload after a successful startup update
 
@@ -55,3 +56,13 @@ Run:
 ```
 
 Pi will prompt you for a package source such as `npm:@foo/bar` or `git:github.com/user/repo`, run the native `pi install ...` flow, and show a final result card. After a successful install, run `/reload` to activate the installed package resources.
+
+### Uninstall package(s)
+
+Run:
+
+```text
+/package-manager uninstall
+```
+
+Pi will show a checkbox-style package picker. Use <space> to toggle package selection, then press Enter to confirm. Pi runs native `pi uninstall <source>` once per selected package and shows one final result card. After successful or partial removal, run `/reload` to deactivate removed package resources.

package/index.ts

@@ -27,6 +27,7 @@ import {
     createAutoUpdateResultReport,
     createInstallResultReport,
     createReportEntryRenderer,
+    createUninstallResultReport,
     createStatusReport,
     formatStatusLines,
     formatUtcTimestamp,
@@ -48,12 +49,13 @@ export default function initPackageManager(
     )
 
     pi.on("session_start", controller.onSessionStart)
+    pi.on("session_shutdown", controller.onSessionShutdown)
 
     pi.registerCommand("package-manager", {
         description:
-            "Manage Pi packages (usage: /package-manager [status|update|install])",
+            "Manage Pi packages (usage: /package-manager [status|update|install|uninstall])",
         getArgumentCompletions: (prefix: string): AutocompleteItem[] | null => {
-            const items = ["status", "update", "install"].map((value) => ({
+            const items = ["status", "update", "install", "uninstall"].map((value) => ({
                 value,
                 label: value,
             }))
@@ -84,7 +86,15 @@ export default function initPackageManager(
                 return
             }
 
-            ctx.ui.notify("Usage: /package-manager [status|update|install]", "warning")
+            if (subcommand === "uninstall") {
+                await controller.handleUninstall(ctx)
+                return
+            }
+
+            ctx.ui.notify(
+                "Usage: /package-manager [status|update|install|uninstall]",
+                "warning",
+            )
         },
     })
 }
@@ -97,6 +107,7 @@ export {
     createAutoUpdateRecord,
     createAutoUpdateResultReport,
     createInstallResultReport,
+    createUninstallResultReport,
     createStatusReport,
     formatStatusLines,
     formatUtcTimestamp,

package/internal/controller.ts

@@ -17,27 +17,35 @@ import {
     createInstallResultReport,
     createStatusErrorReport,
     createStatusReport,
+    createUninstallResultReport,
     getExecDisplayOutput,
     getExecFailureDetail,
     setPackageManagerWidget,
 } from "./reports.ts"
 import { defaultPackageManagerDeps, type PackageManagerDeps } from "./runtime.ts"
+import { promptForPackagesToUninstall } from "./uninstall-picker.ts"
 
 export function createPackageManagerController(
     pi: Pick<ExtensionAPI, "appendEntry" | "sendUserMessage" | "exec">,
     deps: PackageManagerDeps = defaultPackageManagerDeps,
 ) {
+    let sessionIsActive = true
+
     return {
         onSessionStart,
+        onSessionShutdown,
         handleStatus,
         handleUpdate,
         handleInstall,
+        handleUninstall,
     }
 
     async function onSessionStart(
         event: Pick<SessionStartEvent, "reason">,
         _ctx: ExtensionContext,
     ): Promise<void> {
+        sessionIsActive = true
+
         if (!shouldAutoUpdateOnSessionStart(event)) {
             return
         }
@@ -47,6 +55,10 @@ export function createPackageManagerController(
         })
     }
 
+    async function onSessionShutdown(): Promise<void> {
+        sessionIsActive = false
+    }
+
     async function handleStatus(ctx: ExtensionCommandContext): Promise<void> {
         const lastAutoUpdate = getLastAutoUpdateRecord(ctx.sessionManager.getEntries())
 
@@ -54,26 +66,37 @@ export function createPackageManagerController(
 
         try {
             const availableUpdates = await deps.checkForAvailableUpdates(ctx)
-            pi.appendEntry(
-                REPORT_ENTRY_TYPE,
-                createStatusReport({
+
+            if (!isSessionActive()) {
+                return
+            }
+
+            appendReport({
+                type: REPORT_ENTRY_TYPE,
+                report: createStatusReport({
                     availableUpdates,
                     lastAutoUpdate,
                 }),
-            )
+            })
         } catch (error) {
-            pi.appendEntry(
-                REPORT_ENTRY_TYPE,
-                createStatusErrorReport(
+            if (!isSessionActive()) {
+                return
+            }
+
+            appendReport({
+                type: REPORT_ENTRY_TYPE,
+                report: createStatusErrorReport(
                     {
                         availableUpdates: [],
                         lastAutoUpdate,
                     },
                     getErrorMessage(error),
                 ),
-            )
+            })
         } finally {
-            clearPackageManagerWidget(ctx)
+            if (isSessionActive()) {
+                clearPackageManagerWidget(ctx)
+            }
         }
     }
 
@@ -94,6 +117,10 @@ export function createPackageManagerController(
 
             const availableUpdates = await deps.checkForAvailableUpdates(ctx)
 
+            if (!isSessionActive()) {
+                return
+            }
+
             if (availableUpdates.length === 0) {
                 appendSkippedResult(startedAtUtc, "No package updates are available.")
                 return
@@ -105,6 +132,11 @@ export function createPackageManagerController(
             })
 
             const result = await deps.runNativeUpdate(pi, ctx)
+
+            if (!isSessionActive()) {
+                return
+            }
+
             const output = getExecDisplayOutput(result)
 
             if (result.code === 0) {
@@ -114,17 +146,18 @@ export function createPackageManagerController(
                     outcome: "succeeded",
                     packagesUpdated: availableUpdates.length,
                 })
-
-                appendAutoUpdateRecordAndReport(
-                    pi,
+                const report = createAutoUpdateResultReport({
                     record,
-                    createAutoUpdateResultReport({
-                        record,
-                        output,
-                        reloadAfterSeconds: RELOAD_COUNTDOWN_SECONDS,
-                    }),
-                )
-                await runReloadCountdown(ctx)
+                    output,
+                    reloadAfterSeconds: RELOAD_COUNTDOWN_SECONDS,
+                })
+
+                appendAutoUpdateRecordAndReport(pi, record, report)
+
+                if (!(await runReloadCountdown(ctx))) {
+                    return
+                }
+
                 clearPackageManagerWidget(ctx)
                 shouldClearWidget = false
                 await ctx.reload()
@@ -136,16 +169,17 @@ export function createPackageManagerController(
                 endedAtUtc: deps.nowIso(),
                 outcome: "failed",
                 packagesUpdated: 0,
-                reason: getExecFailureDetail(result),
+                reason: getExecFailureDetail(result, "Package update command failed."),
             })
+            const report = createAutoUpdateResultReport({ record, output })
 
-            appendAutoUpdateRecordAndReport(
-                pi,
-                record,
-                createAutoUpdateResultReport({ record, output }),
-            )
+            appendAutoUpdateRecordAndReport(pi, record, report)
             notifyStartupFailure(ctx, options.startupTriggered)
         } catch (error) {
+            if (!isSessionActive()) {
+                return
+            }
+
             const record = createAutoUpdateRecord({
                 startedAtUtc,
                 endedAtUtc: deps.nowIso(),
@@ -153,15 +187,12 @@ export function createPackageManagerController(
                 packagesUpdated: 0,
                 reason: getErrorMessage(error),
             })
+            const report = createAutoUpdateResultReport({ record })
 
-            appendAutoUpdateRecordAndReport(
-                pi,
-                record,
-                createAutoUpdateResultReport({ record }),
-            )
+            appendAutoUpdateRecordAndReport(pi, record, report)
             notifyStartupFailure(ctx, options.startupTriggered)
         } finally {
-            if (shouldClearWidget) {
+            if (shouldClearWidget && isSessionActive()) {
                 clearPackageManagerWidget(ctx)
             }
         }
@@ -183,7 +214,7 @@ export function createPackageManagerController(
             )
         )?.trim()
 
-        if (source === undefined) {
+        if (!isSessionActive() || source === undefined) {
             return
         }
 
@@ -197,46 +228,180 @@ export function createPackageManagerController(
 
         try {
             const result = await deps.runNativeInstall(pi, ctx, source)
+
+            if (!isSessionActive()) {
+                return
+            }
+
             const output = getExecDisplayOutput(result)
+            const report = createInstallResultReport({
+                startedAtUtc,
+                endedAtUtc: deps.nowIso(),
+                source,
+                outcome: result.code === 0 ? "succeeded" : "failed",
+                output,
+                reason:
+                    result.code === 0
+                        ? undefined
+                        : getExecFailureDetail(
+                              result,
+                              "Package install command failed.",
+                          ),
+            })
 
-            if (result.code === 0) {
-                pi.appendEntry(
-                    REPORT_ENTRY_TYPE,
-                    createInstallResultReport({
-                        startedAtUtc,
-                        endedAtUtc: deps.nowIso(),
-                        source,
-                        outcome: "succeeded",
-                        output,
-                    }),
-                )
+            appendReport({ type: REPORT_ENTRY_TYPE, report })
+        } catch (error) {
+            if (!isSessionActive()) {
                 return
             }
 
-            pi.appendEntry(
-                REPORT_ENTRY_TYPE,
-                createInstallResultReport({
+            appendReport({
+                type: REPORT_ENTRY_TYPE,
+                report: createInstallResultReport({
                     startedAtUtc,
                     endedAtUtc: deps.nowIso(),
                     source,
                     outcome: "failed",
-                    output,
-                    reason: getExecFailureDetail(result),
+                    reason: getErrorMessage(error),
                 }),
-            )
-        } catch (error) {
-            pi.appendEntry(
-                REPORT_ENTRY_TYPE,
-                createInstallResultReport({
+            })
+        } finally {
+            if (isSessionActive()) {
+                clearPackageManagerWidget(ctx)
+            }
+        }
+    }
+
+    async function handleUninstall(ctx: ExtensionCommandContext): Promise<void> {
+        if (ctx.mode !== "tui") {
+            ctx.ui.notify("/package-manager uninstall requires TUI mode.", "warning")
+            return
+        }
+
+        const packages = await deps.listConfiguredPackages(ctx)
+
+        if (!isSessionActive()) {
+            return
+        }
+
+        if (packages.length === 0) {
+            ctx.ui.notify("No Pi packages are available to uninstall.", "info")
+            return
+        }
+
+        const selectedSources = await promptForPackagesToUninstall(ctx, packages)
+
+        if (!isSessionActive() || selectedSources === undefined) {
+            return
+        }
+
+        if (selectedSources.length === 0) {
+            ctx.ui.notify("Select at least one package to uninstall.", "warning")
+            return
+        }
+
+        const selectedSourceSet = new Set(selectedSources)
+        const sources = packages
+            .map((pkg) => pkg.source)
+            .filter((source) => selectedSourceSet.has(source))
+
+        if (sources.length === 0) {
+            ctx.ui.notify("Select at least one package to uninstall.", "warning")
+            return
+        }
+
+        const startedAtUtc = deps.nowIso()
+        const succeededSources: string[] = []
+        const failedSources: string[] = []
+        const outputSections: string[] = []
+
+        try {
+            for (const [index, source] of sources.entries()) {
+                setPackageManagerWidget(ctx, {
+                    mode: "package-uninstalling",
+                    current: index + 1,
+                    total: sources.length,
+                    source,
+                })
+
+                const result = await deps.runNativeUninstall(pi, ctx, source)
+
+                if (!isSessionActive()) {
+                    return
+                }
+
+                const output = getExecDisplayOutput(result)
+
+                if (result.code === 0) {
+                    if (output) {
+                        outputSections.push(`[${source}]\n${output}`)
+                    }
+                    succeededSources.push(source)
+                    continue
+                }
+
+                failedSources.push(source)
+                outputSections.push(
+                    `[${source}]\n${output ?? getExecFailureDetail(result, "Package uninstall command failed.")}`,
+                )
+            }
+
+            appendReport({
+                type: REPORT_ENTRY_TYPE,
+                report: createUninstallResultReport({
                     startedAtUtc,
                     endedAtUtc: deps.nowIso(),
-                    source,
-                    outcome: "failed",
-                    reason: getErrorMessage(error),
+                    sources,
+                    outcome:
+                        failedSources.length === 0
+                            ? "succeeded"
+                            : succeededSources.length > 0
+                              ? "partial"
+                              : "failed",
+                    succeededSources,
+                    failedSources,
+                    output:
+                        outputSections.length > 0
+                            ? outputSections.join("\n\n")
+                            : undefined,
+                    reason:
+                        failedSources.length > 0
+                            ? `Failed to uninstall ${failedSources[0]}.`
+                            : undefined,
                 }),
+            })
+        } catch (error) {
+            if (!isSessionActive()) {
+                return
+            }
+
+            const failedSource = sources[succeededSources.length]
+            const errorMessage = getErrorMessage(error)
+
+            if (failedSource && !failedSources.includes(failedSource)) {
+                failedSources.push(failedSource)
+            }
+
+            outputSections.push(
+                failedSource ? `[${failedSource}]\n${errorMessage}` : errorMessage,
             )
+            appendReport({
+                type: REPORT_ENTRY_TYPE,
+                report: createUninstallResultReport({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    sources,
+                    outcome: succeededSources.length > 0 ? "partial" : "failed",
+                    succeededSources,
+                    failedSources,
+                    output: outputSections.join("\n\n"),
+                    reason: errorMessage,
+                }),
+            })
         } finally {
-            clearPackageManagerWidget(ctx)
+            if (isSessionActive()) {
+                clearPackageManagerWidget(ctx)
+            }
         }
     }
 
@@ -248,26 +413,44 @@ export function createPackageManagerController(
             packagesUpdated: 0,
             reason,
         })
+        const report = createAutoUpdateResultReport({ record })
 
-        appendAutoUpdateRecordAndReport(
-            pi,
-            record,
-            createAutoUpdateResultReport({ record }),
-        )
+        appendAutoUpdateRecordAndReport(pi, record, report)
+    }
+
+    function appendReport(entry: {
+        type: string
+        report: ReturnType<typeof createStatusReport>
+    }): void {
+        pi.appendEntry(entry.type, entry.report)
+    }
+
+    function isSessionActive(): boolean {
+        return sessionIsActive
     }
 
     async function runReloadCountdown(
         ctx: ExtensionContext,
         seconds = RELOAD_COUNTDOWN_SECONDS,
-    ): Promise<void> {
+    ): Promise<boolean> {
         for (let remaining = seconds; remaining >= 1; remaining--) {
+            if (!isSessionActive()) {
+                return false
+            }
+
             setPackageManagerWidget(ctx, {
                 mode: "countdown",
                 secondsRemaining: remaining,
             })
 
             await deps.sleep(1000)
+
+            if (!isSessionActive()) {
+                return false
+            }
         }
+
+        return true
     }
 }
 

package/internal/model.ts

@@ -6,9 +6,11 @@ export const RELOAD_COUNTDOWN_SECONDS = 5
 export const OUTPUT_PREVIEW_LINE_COUNT = 8
 export const UPDATE_COMMAND = ["update", "--extensions"] as const
 export const INSTALL_COMMAND = ["install"] as const
+export const UNINSTALL_COMMAND = ["uninstall"] as const
 
 export type AutoUpdateOutcome = "succeeded" | "failed" | "skipped"
 export type InstallOutcome = "succeeded" | "failed"
+export type UninstallOutcome = "succeeded" | "partial" | "failed"
 export type ReportTone = "info" | "success" | "warning" | "error"
 
 export type WidgetState =
@@ -17,6 +19,12 @@ export type WidgetState =
     | { mode: "installing"; packages: number }
     | { mode: "countdown"; secondsRemaining: number }
     | { mode: "package-installing"; source: string }
+    | {
+          mode: "package-uninstalling"
+          current: number
+          total: number
+          source: string
+      }
 
 export interface AutoUpdateRecord {
     startedAtUtc: string
@@ -43,3 +51,9 @@ export interface PackageStatusSnapshot {
     availableUpdates: string[]
     lastAutoUpdate?: AutoUpdateRecord
 }
+
+export interface ConfiguredPackageOption {
+    source: string
+    scope: "user" | "project"
+    filtered: boolean
+}

package/internal/reports.ts

@@ -14,6 +14,7 @@ import {
     type InstallOutcome,
     type PackageManagerReport,
     type PackageStatusSnapshot,
+    type UninstallOutcome,
     type WidgetState,
 } from "./model.ts"
 
@@ -35,81 +36,7 @@ export function createReportEntryRenderer() {
             return undefined
         }
 
-        const toneColor =
-            report.tone === "error"
-                ? "error"
-                : report.tone === "warning"
-                  ? "warning"
-                  : report.tone === "success"
-                    ? "success"
-                    : "accent"
-        const lineTextTone = report.lineTone === "dim" ? "dim" : "customMessageText"
-        const outputTextTone = report.outputTone === "dim" ? "dim" : lineTextTone
-
-        const box = new Box(1, 1, (text: string) => theme.bg("customMessageBg", text))
-
-        box.addChild(
-            new Text(
-                `${theme.fg(toneColor, "●")} ${theme.bold(theme.fg("customMessageLabel", report.title))}`,
-                0,
-                0,
-            ),
-        )
-
-        if (report.headline) {
-            box.addChild(new Text(theme.fg("text", report.headline), 0, 0))
-        }
-
-        if (report.lines.length > 0) {
-            box.addChild(
-                new Text(
-                    report.lines.map((line) => theme.fg(lineTextTone, line)).join("\n"),
-                    0,
-                    0,
-                ),
-            )
-        }
-
-        if (report.output?.trim()) {
-            if (!expanded && report.hideOutputWhenCollapsed) {
-                box.addChild(
-                    new Text(
-                        formatExpandHint(
-                            theme,
-                            `to expand to see ${report.outputDescription ?? "output"}.`,
-                        ),
-                        0,
-                        0,
-                    ),
-                )
-            } else {
-                const { text, truncated } = formatReportOutput(report.output, expanded)
-
-                box.addChild(
-                    new Text(
-                        theme.fg(outputTextTone, report.outputLabel ?? "Output:"),
-                        0,
-                        0,
-                    ),
-                )
-                box.addChild(new Text(theme.fg(outputTextTone, text), 0, 0))
-
-                if (truncated) {
-                    box.addChild(
-                        new Text(
-                            formatExpandHint(
-                                theme,
-                                `to expand to view the full ${report.outputDescription ?? "output"}.`,
-                            ),
-                            0,
-                            0,
-                        ),
-                    )
-                }
-            }
-        }
-
-        return box
+        return createReportBox(report, theme, { expanded })
     }
 }
 
@@ -246,6 +173,53 @@ export function createInstallResultReport(input: {
     }
 }
 
+export function createUninstallResultReport(input: {
+    startedAtUtc: string
+    endedAtUtc: string
+    sources: string[]
+    outcome: UninstallOutcome
+    succeededSources: string[]
+    failedSources: string[]
+    output?: string
+    reason?: string
+}): PackageManagerReport {
+    return {
+        title: PACKAGE_MANAGER_TITLE,
+        headline:
+            input.outcome === "succeeded"
+                ? "Pi package uninstall completed."
+                : input.outcome === "partial"
+                  ? "Pi package uninstall partially completed."
+                  : "Pi package uninstall failed.",
+        tone:
+            input.outcome === "succeeded"
+                ? "success"
+                : input.outcome === "partial"
+                  ? "warning"
+                  : "error",
+        lines: [
+            `Start: ${formatUtcTimestamp(input.startedAtUtc)}`,
+            `End: ${formatUtcTimestamp(input.endedAtUtc)}`,
+            `Result: ${input.outcome}`,
+            `Packages selected: ${input.sources.length}`,
+            ...input.sources.map((source) => `Package source: ${source}`),
+            `Packages removed: ${input.succeededSources.length}`,
+            ...(input.failedSources.length > 0
+                ? [`Packages failed: ${input.failedSources.length}`]
+                : ["Run /reload to deactivate removed package resources."]),
+            ...(input.reason ? [`Latest failure detail: ${input.reason}`] : []),
+        ],
+        lineTone: "dim",
+        output: input.output,
+        outputLabel:
+            input.outcome === "succeeded" ? "Uninstall output:" : "Error detail:",
+        outputDescription:
+            input.outcome === "succeeded" ? "uninstall output" : "error detail",
+        outputTone: "dim",
+        hideOutputWhenCollapsed: true,
+    }
+}
+
 export function createAutomaticUpdateWidgetLines(state: WidgetState): string[] {
     if (state.mode === "status-checking") {
         return ["Pi package status in progress.", "Checking for package updates..."]
@@ -272,6 +246,13 @@ export function createAutomaticUpdateWidgetLines(state: WidgetState): string[] {
         ]
     }
 
+    if (state.mode === "package-uninstalling") {
+        return [
+            "Pi package uninstall in progress.",
+            `Removing ${state.current}/${state.total}: ${state.source}`,
+        ]
+    }
+
     return [
         formatAutomaticUpdateHeadline("succeeded"),
         `Reloading in ${state.secondsRemaining} second${state.secondsRemaining === 1 ? "" : "s"} to activate updated package resources.`,
@@ -288,39 +269,12 @@ export function setPackageManagerWidget(
 
     ctx.ui.setWidget(
         PACKAGE_MANAGER_WIDGET_KEY,
-        (_tui, theme) => {
-            const background =
-                state.mode === "countdown"
-                    ? (text: string) => theme.bg("toolSuccessBg", text)
-                    : (text: string) => theme.bg("toolPendingBg", text)
-            const box = new Box(1, 1, background)
-            const titleColor = state.mode === "countdown" ? "success" : "accent"
-            const bodyLines = createAutomaticUpdateWidgetLines(state)
-
-            box.addChild(
-                new Text(
-                    `${theme.fg(titleColor, "●")} ${theme.bold(theme.fg("customMessageLabel", PACKAGE_MANAGER_TITLE))}`,
-                    0,
-                    0,
-                ),
-            )
-            box.addChild(
-                new Text(
-                    bodyLines
-                        .map((line, index) =>
-                            theme.fg(
-                                index === bodyLines.length - 1 ? "dim" : "text",
-                                line,
-                            ),
-                        )
-                        .join("\n"),
-                    0,
-                    0,
-                ),
-            )
-
-            return box
-        },
+        (_tui, theme) =>
+            createStatusBox(theme, createAutomaticUpdateWidgetLines(state), {
+                titleColor: state.mode === "countdown" ? "success" : "accent",
+                background:
+                    state.mode === "countdown" ? "toolSuccessBg" : "toolPendingBg",
+            }),
         { placement: "aboveEditor" },
     )
 }
@@ -349,10 +303,13 @@ export function getExecDisplayOutput(result: ExecResult): string | undefined {
     return sections.length > 0 ? sections.join("\n\n") : undefined
 }
 
-export function getExecFailureDetail(result: ExecResult): string {
+export function getExecFailureDetail(
+    result: ExecResult,
+    fallback = "Package command failed.",
+): string {
     const stderr = result.stderr.trim()
     const stdout = result.stdout.trim()
-    const detail = stderr || stdout || "Package update command failed."
+    const detail = stderr || stdout || fallback
 
     return detail.length > 400 ? `${detail.slice(0, 397)}...` : detail
 }
@@ -370,6 +327,115 @@ function formatAutomaticUpdateHeadline(
     return `Pi package(s) update ${suffix}.`
 }
 
+function createReportBox(
+    report: PackageManagerReport,
+    theme: ThemeLike,
+    options: { expanded: boolean },
+): Box {
+    const toneColor =
+        report.tone === "error"
+            ? "error"
+            : report.tone === "warning"
+              ? "warning"
+              : report.tone === "success"
+                ? "success"
+                : "accent"
+    const lineTextTone = report.lineTone === "dim" ? "dim" : "customMessageText"
+    const outputTextTone = report.outputTone === "dim" ? "dim" : lineTextTone
+    const box = new Box(1, 1, (text: string) => theme.bg("customMessageBg", text))
+
+    box.addChild(
+        new Text(
+            `${theme.fg(toneColor, "●")} ${theme.bold(theme.fg("customMessageLabel", report.title))}`,
+            0,
+            0,
+        ),
+    )
+
+    if (report.headline) {
+        box.addChild(new Text(theme.fg("text", report.headline), 0, 0))
+    }
+
+    if (report.lines.length > 0) {
+        box.addChild(
+            new Text(
+                report.lines.map((line) => theme.fg(lineTextTone, line)).join("\n"),
+                0,
+                0,
+            ),
+        )
+    }
+
+    if (!report.output?.trim()) {
+        return box
+    }
+
+    if (!options.expanded && report.hideOutputWhenCollapsed) {
+        box.addChild(
+            new Text(
+                formatExpandHint(
+                    theme,
+                    `to expand to see ${report.outputDescription ?? "output"}.`,
+                ),
+                0,
+                0,
+            ),
+        )
+        return box
+    }
+
+    const { text, truncated } = formatReportOutput(report.output, options.expanded)
+
+    box.addChild(
+        new Text(theme.fg(outputTextTone, report.outputLabel ?? "Output:"), 0, 0),
+    )
+    box.addChild(new Text(theme.fg(outputTextTone, text), 0, 0))
+
+    if (truncated) {
+        box.addChild(
+            new Text(
+                formatExpandHint(
+                    theme,
+                    `to expand to view the full ${report.outputDescription ?? "output"}.`,
+                ),
+                0,
+                0,
+            ),
+        )
+    }
+
+    return box
+}
+
+function createStatusBox(
+    theme: ThemeLike,
+    bodyLines: string[],
+    options: { titleColor: string; background: string },
+): Box {
+    const box = new Box(1, 1, (text: string) => theme.bg(options.background, text))
+
+    box.addChild(
+        new Text(
+            `${theme.fg(options.titleColor, "●")} ${theme.bold(theme.fg("customMessageLabel", PACKAGE_MANAGER_TITLE))}`,
+            0,
+            0,
+        ),
+    )
+    box.addChild(
+        new Text(
+            bodyLines
+                .map((line, index) =>
+                    theme.fg(index === bodyLines.length - 1 ? "dim" : "text", line),
+                )
+                .join("\n"),
+            0,
+            0,
+        ),
+    )
+
+    return box
+}
+
 function formatExpandHint(theme: ThemeLike, description: string): string {
     const expandKey = keyText("app.tools.expand") || "Ctrl+O"
 

package/internal/runtime.ts

@@ -8,13 +8,19 @@ import {
     type ExtensionContext,
 } from "@earendil-works/pi-coding-agent"
 
-import { INSTALL_COMMAND, UPDATE_COMMAND } from "./model.ts"
+import {
+    INSTALL_COMMAND,
+    UNINSTALL_COMMAND,
+    UPDATE_COMMAND,
+    type ConfiguredPackageOption,
+} from "./model.ts"
 
 export interface PackageManagerDeps {
     nowIso(): string
     sleep(milliseconds: number): Promise<void>
     isOffline(): boolean
     checkForAvailableUpdates(ctx: ExtensionContext): Promise<string[]>
+    listConfiguredPackages(ctx: ExtensionContext): Promise<ConfiguredPackageOption[]>
     runNativeUpdate(
         pi: Pick<ExtensionAPI, "exec">,
         ctx: ExtensionCommandContext,
@@ -24,6 +30,11 @@ export interface PackageManagerDeps {
         ctx: ExtensionCommandContext,
         source: string,
     ): Promise<ExecResult>
+    runNativeUninstall(
+        pi: Pick<ExtensionAPI, "exec">,
+        ctx: ExtensionCommandContext,
+        source: string,
+    ): Promise<ExecResult>
 }
 
 export const defaultPackageManagerDeps: PackageManagerDeps = {
@@ -35,21 +46,25 @@ export const defaultPackageManagerDeps: PackageManagerDeps = {
     },
     isOffline: () => Boolean(process.env.PI_OFFLINE),
     async checkForAvailableUpdates(ctx: ExtensionContext): Promise<string[]> {
-        const agentDir = getAgentDir()
-        const settingsManager = SettingsManager.create(ctx.cwd, agentDir, {
-            projectTrusted: ctx.isProjectTrusted(),
-        })
-        const packageManager = new DefaultPackageManager({
-            cwd: ctx.cwd,
-            agentDir,
-            settingsManager,
-        })
+        const packageManager = createDefaultPackageManager(ctx)
         const updates = await packageManager.checkForAvailableUpdates()
 
         return updates
             .map((update) => update.displayName)
             .sort((left, right) => left.localeCompare(right))
     },
+    async listConfiguredPackages(
+        ctx: ExtensionContext,
+    ): Promise<ConfiguredPackageOption[]> {
+        return createDefaultPackageManager(ctx)
+            .listConfiguredPackages()
+            .map((pkg) => ({
+                source: pkg.source,
+                scope: pkg.scope,
+                filtered: pkg.filtered,
+            }))
+            .sort((left, right) => left.source.localeCompare(right.source))
+    },
     runNativeUpdate(pi: Pick<ExtensionAPI, "exec">, ctx: ExtensionCommandContext) {
         return pi.exec("pi", [...UPDATE_COMMAND], {
             cwd: ctx.cwd,
@@ -66,4 +81,27 @@ export const defaultPackageManagerDeps: PackageManagerDeps = {
             signal: ctx.signal,
         })
     },
+    runNativeUninstall(
+        pi: Pick<ExtensionAPI, "exec">,
+        ctx: ExtensionCommandContext,
+        source: string,
+    ) {
+        return pi.exec("pi", [...UNINSTALL_COMMAND, source], {
+            cwd: ctx.cwd,
+            signal: ctx.signal,
+        })
+    },
+}
+
+function createDefaultPackageManager(ctx: ExtensionContext): DefaultPackageManager {
+    const agentDir = getAgentDir()
+    const settingsManager = SettingsManager.create(ctx.cwd, agentDir, {
+        projectTrusted: ctx.isProjectTrusted(),
+    })
+
+    return new DefaultPackageManager({
+        cwd: ctx.cwd,
+        agentDir,
+        settingsManager,
+    })
 }

package/internal/uninstall-picker.ts

@@ -0,0 +1,144 @@
+import {
+    DynamicBorder,
+    type ExtensionCommandContext,
+    type Theme,
+} from "@earendil-works/pi-coding-agent"
+import {
+    Container,
+    Key,
+    SelectList,
+    Text,
+    type Component,
+    type SelectItem,
+    type TUI,
+    matchesKey,
+} from "@earendil-works/pi-tui"
+
+import type { ConfiguredPackageOption } from "./model.ts"
+
+export async function promptForPackagesToUninstall(
+    ctx: Pick<ExtensionCommandContext, "ui">,
+    packages: ConfiguredPackageOption[],
+): Promise<string[] | undefined> {
+    return ctx.ui.custom<string[] | undefined>(
+        (tui, theme, _keybindings, done) => {
+            const picker = new PackageUninstallPicker(tui, theme, packages)
+            picker.done = done
+            return picker
+        },
+        {
+            overlay: true,
+            overlayOptions: {
+                width: "70%",
+                minWidth: 48,
+                maxHeight: "80%",
+            },
+        },
+    )
+}
+
+class PackageUninstallPicker implements Component {
+    private readonly container = new Container()
+    private readonly title = new Text("", 1, 0)
+    private readonly summary = new Text("", 1, 0)
+    private readonly footer = new Text("", 1, 0)
+    private readonly checkedSources = new Set<string>()
+    private readonly items: SelectItem[]
+    private readonly selectList: SelectList
+    private readonly tui: TUI
+    private readonly theme: Theme
+
+    constructor(tui: TUI, theme: Theme, packages: ConfiguredPackageOption[]) {
+        this.tui = tui
+        this.theme = theme
+        this.items = packages.map((pkg) => ({
+            value: pkg.source,
+            label: formatPackageOptionLabel(pkg.source, false),
+        }))
+        this.selectList = new SelectList(this.items, Math.min(this.items.length, 10), {
+            selectedPrefix: (text) => this.theme.fg("accent", text),
+            selectedText: (text) => this.theme.fg("accent", text),
+            description: (text) => this.theme.fg("muted", text),
+            scrollInfo: (text) => this.theme.fg("dim", text),
+            noMatch: (text) => this.theme.fg("warning", text),
+        })
+
+        this.selectList.onSelect = () => {
+            this.done?.(Array.from(this.checkedSources))
+        }
+        this.selectList.onCancel = () => {
+            this.done?.(undefined)
+        }
+
+        this.container.addChild(
+            new DynamicBorder((text: string) => this.theme.fg("accent", text)),
+        )
+        this.container.addChild(this.title)
+        this.container.addChild(this.summary)
+        this.container.addChild(this.selectList)
+        this.container.addChild(this.footer)
+        this.container.addChild(
+            new DynamicBorder((text: string) => this.theme.fg("accent", text)),
+        )
+
+        this.refreshText()
+    }
+
+    done?: (value: string[] | undefined) => void
+
+    handleInput(data: string): void {
+        if (matchesKey(data, Key.space)) {
+            this.toggleSelectedItem()
+            this.tui.requestRender()
+            return
+        }
+
+        this.selectList.handleInput(data)
+        this.tui.requestRender()
+    }
+
+    invalidate(): void {
+        this.container.invalidate()
+        this.refreshText()
+    }
+
+    render(width: number): string[] {
+        return this.container.render(width)
+    }
+
+    private refreshText(): void {
+        this.title.setText(
+            this.theme.fg("accent", this.theme.bold("Select Pi Packages to Uninstall")),
+        )
+        this.summary.setText(
+            this.theme.fg(
+                "dim",
+                `${this.checkedSources.size} selected • enter confirm • esc cancel`,
+            ),
+        )
+        this.footer.setText(this.theme.fg("dim", "↑↓ navigate • space toggle checkbox"))
+    }
+
+    private toggleSelectedItem(): void {
+        const selectedItem = this.selectList.getSelectedItem()
+
+        if (!selectedItem) {
+            return
+        }
+
+        if (this.checkedSources.has(selectedItem.value)) {
+            this.checkedSources.delete(selectedItem.value)
+            selectedItem.label = formatPackageOptionLabel(selectedItem.value, false)
+        } else {
+            this.checkedSources.add(selectedItem.value)
+            selectedItem.label = formatPackageOptionLabel(selectedItem.value, true)
+        }
+
+        this.selectList.invalidate()
+        this.refreshText()
+    }
+}
+
+function formatPackageOptionLabel(source: string, checked: boolean): string {
+    return `${checked ? "[x]" : "[ ]"} ${source}`
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gaosh3n/pi-package-manager",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "Package Manager for Pi",
     "type": "module",
     "packageManager": "pnpm@11.23.0",