@gaosh3n/pi-package-manager 0.1.2 → 0.1.3

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,
@@ -51,9 +52,9 @@ export default function initPackageManager(
 
     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 +85,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 +106,7 @@ export {
     createAutoUpdateRecord,
     createAutoUpdateResultReport,
     createInstallResultReport,
+    createUninstallResultReport,
     createStatusReport,
     formatStatusLines,
     formatUtcTimestamp,

package/internal/controller.ts

@@ -17,11 +17,13 @@ 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">,
@@ -32,6 +34,7 @@ export function createPackageManagerController(
         handleStatus,
         handleUpdate,
         handleInstall,
+        handleUninstall,
     }
 
     async function onSessionStart(
@@ -136,7 +139,7 @@ export function createPackageManagerController(
                 endedAtUtc: deps.nowIso(),
                 outcome: "failed",
                 packagesUpdated: 0,
-                reason: getExecFailureDetail(result),
+                reason: getExecFailureDetail(result, "Package update command failed."),
             })
 
             appendAutoUpdateRecordAndReport(
@@ -221,7 +224,10 @@ export function createPackageManagerController(
                     source,
                     outcome: "failed",
                     output,
-                    reason: getExecFailureDetail(result),
+                    reason: getExecFailureDetail(
+                        result,
+                        "Package install command failed.",
+                    ),
                 }),
             )
         } catch (error) {
@@ -240,6 +246,124 @@ export function createPackageManagerController(
         }
     }
 
+    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 (packages.length === 0) {
+            ctx.ui.notify("No Pi packages are available to uninstall.", "info")
+            return
+        }
+
+        const selectedSources = await promptForPackagesToUninstall(ctx, packages)
+
+        if (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)
+                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.")}`,
+                )
+            }
+
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createUninstallResultReport({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    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) {
+            const failedSource = sources[succeededSources.length]
+            const errorMessage = getErrorMessage(error)
+
+            if (failedSource && !failedSources.includes(failedSource)) {
+                failedSources.push(failedSource)
+            }
+
+            outputSections.push(
+                failedSource ? `[${failedSource}]\n${errorMessage}` : errorMessage,
+            )
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createUninstallResultReport({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    sources,
+                    outcome: succeededSources.length > 0 ? "partial" : "failed",
+                    succeededSources,
+                    failedSources,
+                    output: outputSections.join("\n\n"),
+                    reason: errorMessage,
+                }),
+            )
+        } finally {
+            clearPackageManagerWidget(ctx)
+        }
+    }
+
     function appendSkippedResult(startedAtUtc: string, reason: string): void {
         const record = createAutoUpdateRecord({
             startedAtUtc,

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"
 
@@ -246,6 +247,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 +320,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.`,
@@ -349,10 +404,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
 }

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.3",
     "description": "Package Manager for Pi",
     "type": "module",
     "packageManager": "pnpm@11.23.0",