@gaosh3n/pi-package-manager 0.1.0 → 0.1.2

package/internal/controller.ts

@@ -0,0 +1,298 @@
+import {
+    type ExtensionAPI,
+    type ExtensionCommandContext,
+    type ExtensionContext,
+    type SessionStartEvent,
+} from "@earendil-works/pi-coding-agent"
+
+import { RELOAD_COUNTDOWN_SECONDS, REPORT_ENTRY_TYPE } from "./model.ts"
+import {
+    appendAutoUpdateRecordAndReport,
+    createAutoUpdateRecord,
+    getLastAutoUpdateRecord,
+} from "./records.ts"
+import {
+    clearPackageManagerWidget,
+    createAutoUpdateResultReport,
+    createInstallResultReport,
+    createStatusErrorReport,
+    createStatusReport,
+    getExecDisplayOutput,
+    getExecFailureDetail,
+    setPackageManagerWidget,
+} from "./reports.ts"
+import { defaultPackageManagerDeps, type PackageManagerDeps } from "./runtime.ts"
+
+export function createPackageManagerController(
+    pi: Pick<ExtensionAPI, "appendEntry" | "sendUserMessage" | "exec">,
+    deps: PackageManagerDeps = defaultPackageManagerDeps,
+) {
+    return {
+        onSessionStart,
+        handleStatus,
+        handleUpdate,
+        handleInstall,
+    }
+
+    async function onSessionStart(
+        event: Pick<SessionStartEvent, "reason">,
+        _ctx: ExtensionContext,
+    ): Promise<void> {
+        if (!shouldAutoUpdateOnSessionStart(event)) {
+            return
+        }
+
+        pi.sendUserMessage("/package-manager update --startup", {
+            expandPromptTemplates: true,
+        })
+    }
+
+    async function handleStatus(ctx: ExtensionCommandContext): Promise<void> {
+        const lastAutoUpdate = getLastAutoUpdateRecord(ctx.sessionManager.getEntries())
+
+        setPackageManagerWidget(ctx, { mode: "status-checking" })
+
+        try {
+            const availableUpdates = await deps.checkForAvailableUpdates(ctx)
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createStatusReport({
+                    availableUpdates,
+                    lastAutoUpdate,
+                }),
+            )
+        } catch (error) {
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createStatusErrorReport(
+                    {
+                        availableUpdates: [],
+                        lastAutoUpdate,
+                    },
+                    getErrorMessage(error),
+                ),
+            )
+        } finally {
+            clearPackageManagerWidget(ctx)
+        }
+    }
+
+    async function handleUpdate(
+        ctx: ExtensionCommandContext,
+        options: { startupTriggered: boolean },
+    ): Promise<void> {
+        const startedAtUtc = deps.nowIso()
+        let shouldClearWidget = true
+
+        setPackageManagerWidget(ctx, { mode: "checking" })
+
+        try {
+            if (deps.isOffline()) {
+                appendSkippedResult(startedAtUtc, "PI_OFFLINE is set.")
+                return
+            }
+
+            const availableUpdates = await deps.checkForAvailableUpdates(ctx)
+
+            if (availableUpdates.length === 0) {
+                appendSkippedResult(startedAtUtc, "No package updates are available.")
+                return
+            }
+
+            setPackageManagerWidget(ctx, {
+                mode: "installing",
+                packages: availableUpdates.length,
+            })
+
+            const result = await deps.runNativeUpdate(pi, ctx)
+            const output = getExecDisplayOutput(result)
+
+            if (result.code === 0) {
+                const record = createAutoUpdateRecord({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    outcome: "succeeded",
+                    packagesUpdated: availableUpdates.length,
+                })
+
+                appendAutoUpdateRecordAndReport(
+                    pi,
+                    record,
+                    createAutoUpdateResultReport({
+                        record,
+                        output,
+                        reloadAfterSeconds: RELOAD_COUNTDOWN_SECONDS,
+                    }),
+                )
+                await runReloadCountdown(ctx)
+                clearPackageManagerWidget(ctx)
+                shouldClearWidget = false
+                await ctx.reload()
+                return
+            }
+
+            const record = createAutoUpdateRecord({
+                startedAtUtc,
+                endedAtUtc: deps.nowIso(),
+                outcome: "failed",
+                packagesUpdated: 0,
+                reason: getExecFailureDetail(result),
+            })
+
+            appendAutoUpdateRecordAndReport(
+                pi,
+                record,
+                createAutoUpdateResultReport({ record, output }),
+            )
+            notifyStartupFailure(ctx, options.startupTriggered)
+        } catch (error) {
+            const record = createAutoUpdateRecord({
+                startedAtUtc,
+                endedAtUtc: deps.nowIso(),
+                outcome: "failed",
+                packagesUpdated: 0,
+                reason: getErrorMessage(error),
+            })
+
+            appendAutoUpdateRecordAndReport(
+                pi,
+                record,
+                createAutoUpdateResultReport({ record }),
+            )
+            notifyStartupFailure(ctx, options.startupTriggered)
+        } finally {
+            if (shouldClearWidget) {
+                clearPackageManagerWidget(ctx)
+            }
+        }
+    }
+
+    async function handleInstall(ctx: ExtensionCommandContext): Promise<void> {
+        if (!ctx.hasUI) {
+            ctx.ui.notify(
+                "/package-manager install requires dialog-capable UI.",
+                "warning",
+            )
+            return
+        }
+
+        const source = (
+            await ctx.ui.input(
+                "Install Pi Package",
+                "npm:@scope/pkg or git:github.com/user/repo",
+            )
+        )?.trim()
+
+        if (source === undefined) {
+            return
+        }
+
+        if (!source) {
+            ctx.ui.notify("Package source is required.", "warning")
+            return
+        }
+
+        const startedAtUtc = deps.nowIso()
+        setPackageManagerWidget(ctx, { mode: "package-installing", source })
+
+        try {
+            const result = await deps.runNativeInstall(pi, ctx, source)
+            const output = getExecDisplayOutput(result)
+
+            if (result.code === 0) {
+                pi.appendEntry(
+                    REPORT_ENTRY_TYPE,
+                    createInstallResultReport({
+                        startedAtUtc,
+                        endedAtUtc: deps.nowIso(),
+                        source,
+                        outcome: "succeeded",
+                        output,
+                    }),
+                )
+                return
+            }
+
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createInstallResultReport({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    source,
+                    outcome: "failed",
+                    output,
+                    reason: getExecFailureDetail(result),
+                }),
+            )
+        } catch (error) {
+            pi.appendEntry(
+                REPORT_ENTRY_TYPE,
+                createInstallResultReport({
+                    startedAtUtc,
+                    endedAtUtc: deps.nowIso(),
+                    source,
+                    outcome: "failed",
+                    reason: getErrorMessage(error),
+                }),
+            )
+        } finally {
+            clearPackageManagerWidget(ctx)
+        }
+    }
+
+    function appendSkippedResult(startedAtUtc: string, reason: string): void {
+        const record = createAutoUpdateRecord({
+            startedAtUtc,
+            endedAtUtc: deps.nowIso(),
+            outcome: "skipped",
+            packagesUpdated: 0,
+            reason,
+        })
+
+        appendAutoUpdateRecordAndReport(
+            pi,
+            record,
+            createAutoUpdateResultReport({ record }),
+        )
+    }
+
+    async function runReloadCountdown(
+        ctx: ExtensionContext,
+        seconds = RELOAD_COUNTDOWN_SECONDS,
+    ): Promise<void> {
+        for (let remaining = seconds; remaining >= 1; remaining--) {
+            setPackageManagerWidget(ctx, {
+                mode: "countdown",
+                secondsRemaining: remaining,
+            })
+
+            await deps.sleep(1000)
+        }
+    }
+}
+
+export function shouldAutoUpdateOnSessionStart(
+    event: Pick<SessionStartEvent, "reason">,
+): boolean {
+    return event.reason === "startup"
+}
+
+function notifyStartupFailure(
+    ctx: ExtensionCommandContext,
+    startupTriggered: boolean,
+): void {
+    if (startupTriggered && ctx.hasUI) {
+        ctx.ui.notify(
+            "Pi Package Manager automatic startup update failed. See transcript for details.",
+            "error",
+        )
+    }
+}
+
+function getErrorMessage(error: unknown): string {
+    if (error instanceof Error) {
+        return error.message
+    }
+
+    return String(error)
+}

package/internal/model.ts

@@ -0,0 +1,45 @@
+export const AUTO_UPDATE_RECORD_ENTRY_TYPE = "package-manager-auto-update-record"
+export const REPORT_ENTRY_TYPE = "package-manager-report"
+export const PACKAGE_MANAGER_TITLE = "Pi Package Manager"
+export const PACKAGE_MANAGER_WIDGET_KEY = "pi-package-manager"
+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 type AutoUpdateOutcome = "succeeded" | "failed" | "skipped"
+export type InstallOutcome = "succeeded" | "failed"
+export type ReportTone = "info" | "success" | "warning" | "error"
+
+export type WidgetState =
+    | { mode: "status-checking" }
+    | { mode: "checking" }
+    | { mode: "installing"; packages: number }
+    | { mode: "countdown"; secondsRemaining: number }
+    | { mode: "package-installing"; source: string }
+
+export interface AutoUpdateRecord {
+    startedAtUtc: string
+    endedAtUtc: string
+    outcome: AutoUpdateOutcome
+    packagesUpdated: number
+    reason?: string
+}
+
+export interface PackageManagerReport {
+    title: string
+    headline?: string
+    tone: ReportTone
+    lines: string[]
+    lineTone?: "default" | "dim"
+    output?: string
+    outputLabel?: string
+    outputDescription?: string
+    outputTone?: "default" | "dim"
+    hideOutputWhenCollapsed?: boolean
+}
+
+export interface PackageStatusSnapshot {
+    availableUpdates: string[]
+    lastAutoUpdate?: AutoUpdateRecord
+}

package/internal/records.ts

@@ -0,0 +1,81 @@
+import {
+    type CustomEntry,
+    type ExtensionAPI,
+    type SessionEntry,
+} from "@earendil-works/pi-coding-agent"
+
+import {
+    AUTO_UPDATE_RECORD_ENTRY_TYPE,
+    REPORT_ENTRY_TYPE,
+    type AutoUpdateOutcome,
+    type AutoUpdateRecord,
+    type PackageManagerReport,
+} from "./model.ts"
+
+export function createAutoUpdateRecord(input: {
+    startedAtUtc: string
+    endedAtUtc: string
+    outcome: AutoUpdateOutcome
+    packagesUpdated: number
+    reason?: string
+}): AutoUpdateRecord {
+    return {
+        startedAtUtc: input.startedAtUtc,
+        endedAtUtc: input.endedAtUtc,
+        outcome: input.outcome,
+        packagesUpdated: input.packagesUpdated,
+        reason: input.reason,
+    }
+}
+
+export function appendAutoUpdateRecordAndReport(
+    pi: Pick<ExtensionAPI, "appendEntry">,
+    record: AutoUpdateRecord,
+    report: PackageManagerReport,
+): void {
+    pi.appendEntry(AUTO_UPDATE_RECORD_ENTRY_TYPE, record)
+    pi.appendEntry(REPORT_ENTRY_TYPE, report)
+}
+
+export function getLastAutoUpdateRecord(
+    entries: readonly SessionEntry[],
+): AutoUpdateRecord | undefined {
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index]
+
+        if (!isAutoUpdateRecordEntry(entry)) {
+            continue
+        }
+
+        return entry.data
+    }
+
+    return undefined
+}
+
+export function isAutoUpdateRecordEntry(
+    entry: SessionEntry,
+): entry is CustomEntry<AutoUpdateRecord> {
+    return (
+        entry.type === "custom" &&
+        entry.customType === AUTO_UPDATE_RECORD_ENTRY_TYPE &&
+        isAutoUpdateRecord(entry.data)
+    )
+}
+
+export function isAutoUpdateRecord(value: unknown): value is AutoUpdateRecord {
+    if (!value || typeof value !== "object") {
+        return false
+    }
+
+    const candidate = value as Partial<AutoUpdateRecord>
+    return (
+        typeof candidate.startedAtUtc === "string" &&
+        typeof candidate.endedAtUtc === "string" &&
+        (candidate.outcome === "succeeded" ||
+            candidate.outcome === "failed" ||
+            candidate.outcome === "skipped") &&
+        typeof candidate.packagesUpdated === "number" &&
+        (candidate.reason === undefined || typeof candidate.reason === "string")
+    )
+}