pi-requesty-discover 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",
@@ -37,7 +37,8 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "pi": {
     "extensions": [
@@ -45,6 +46,7 @@
     ]
   },
   "devDependencies": {
+    "@earendil-works/pi-tui": "^0.80.3",
     "@eslint/js": "^10.0.1",
     "@types/node": "^26.1.0",
     "@vitest/coverage-v8": "^4.1.9",

package/src/index.ts

@@ -1,13 +1,9 @@
-import {
-  BorderedLoader,
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ProviderModelConfig,
-} from '@earendil-works/pi-coding-agent'
+import { ExtensionAPI, ExtensionCommandContext, ProviderModelConfig } from '@earendil-works/pi-coding-agent'
 import { getEnv } from './env'
 import { getRequestyConfig, updateModelsJson } from './models-json'
 import { discoverModels } from './requesty-api'
 import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
+import { RequestyStatusLoader } from './ui/requesty-status-loader.ts'
 
 const COMMAND_NAME = 'requesty-discover'
 const DRY_RUN_ARG = '--dry-run'
@@ -18,7 +14,16 @@ interface AutocompleteItem {
   description: string
 }
 
-type NotificationLevel = 'info' | 'warning' | 'error'
+export type NotificationLevel = 'info' | 'warning' | 'error'
+
+export type Notifier = {
+  notify(message: string, level?: NotificationLevel): void
+}
+
+export type StatusReporter = {
+  set(message: string): void
+  clear(): void
+}
 
 // noinspection JSUnusedGlobalSymbols
 export default function (pi: ExtensionAPI) {
@@ -26,37 +31,38 @@ export default function (pi: ExtensionAPI) {
     description: 'Dynamically discover Requesty models, run health checks, and update the local models.json.',
     getArgumentCompletions,
     handler: async (args, ctx) => {
-      await withLoader(ctx, 'Discovering models...', () => runCommand(args, ctx))
+      await runWithStatusUi(ctx, 'Discovering models...', (status, notifier) => runCommand(args, status, notifier))
     },
   })
 }
 
-async function withLoader<T>(ctx: ExtensionCommandContext, message: string, fn: () => Promise<T>): Promise<T> {
+async function runWithStatusUi<T>(
+  ctx: ExtensionCommandContext,
+  initialMessage: string,
+  fn: (status: StatusReporter, notifier: Notifier) => Promise<T>,
+): Promise<T> {
+  if (ctx.mode !== 'tui') {
+    return fn(createNoopStatusReporter(), createNoopNotifier())
+  }
+
   return ctx.ui.custom<T>((_tui, theme, _kb, done) => {
-    const loader = new BorderedLoader(_tui, theme, message, { cancellable: false })
-    fn().then(done).catch(done)
+    const loader = new RequestyStatusLoader(_tui, theme, initialMessage)
+    const notifier = createUiNotifier(ctx)
+    const status = createLoaderStatusReporter(loader)
+    void Promise.resolve()
+      .then(() => fn(status, notifier))
+      .then(done)
+      .catch(done)
     return loader
   })
 }
 
-function getArgumentCompletions(prefix: string): AutocompleteItem[] {
-  const options = [
-    {
-      value: DRY_RUN_ARG,
-      label: DRY_RUN_ARG,
-      description: 'Preview without writing into the new model.json file',
-    },
-  ]
-  if (!prefix) return options
-  return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
-}
-
-async function runCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
-  ctx.ui.setStatus(COMMAND_NAME, 'Discovering Requesty models...')
+export async function runCommand(args: string, status: StatusReporter, notifier: Notifier): Promise<void> {
+  status.set('Discovering Requesty models...')
   const parts = args.split(' ')
   const dryRun = parts.includes(DRY_RUN_ARG)
   if (dryRun) {
-    notify(ctx, 'running in dry mode, no changes will be done')
+    notifier.notify('running in dry mode, no changes will be done', undefined)
   }
 
   try {
@@ -71,10 +77,10 @@ async function runCommand(args: string, ctx: ExtensionCommandContext): Promise<v
     let healthCheckSummary = ''
 
     if (env.health_check_mode !== 'off') {
-      ctx.ui.setStatus(COMMAND_NAME, `Checking models 0/${models.length}...`)
+      status.set(`Checking models 0/${models.length}...`)
       const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
         onProgress: ({ completed, total }) => {
-          ctx.ui.setStatus(COMMAND_NAME, `Checking models ${completed}/${total}...`)
+          status.set(`Checking models ${completed}/${total}...`)
         },
       })
       const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
@@ -99,20 +105,66 @@ async function runCommand(args: string, ctx: ExtensionCommandContext): Promise<v
     const message = `Discovered ${models.length} Requesty model(s).\n${healthCheckSummary}${logNote}${writeNote}`
 
     if (failed.length === 0) {
-      notify(ctx, message, 'info')
+      notifier.notify(message, 'info')
     } else if (failed.length < models.length) {
-      notify(ctx, message, 'warning')
+      notifier.notify(message, 'warning')
     } else {
-      notify(ctx, message, 'error')
+      notifier.notify(message, 'error')
     }
   } catch (error) {
-    notify(ctx, `Discovery failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+    notifier.notify(`Discovery failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
   } finally {
-    ctx.ui.setStatus(COMMAND_NAME, undefined)
+    status.clear()
+  }
+}
+
+function getArgumentCompletions(prefix: string): AutocompleteItem[] {
+  const options = [
+    {
+      value: DRY_RUN_ARG,
+      label: DRY_RUN_ARG,
+      description: 'Preview without writing into the new model.json file',
+    },
+  ]
+  if (!prefix) return options
+  return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
+}
+
+function createNoopStatusReporter(): StatusReporter {
+  return {
+    set() {
+      // Status output is only rendered in TUI mode.
+    },
+    clear() {
+      // Status output is only rendered in TUI mode.
+    },
   }
 }
 
-function notify(ctx: ExtensionCommandContext, message: string, level?: NotificationLevel): void {
-  const prefixedMessage = `${COMMAND_NAME}: ${message}`
-  ctx.ui.notify(prefixedMessage, level)
+function createNoopNotifier(): Notifier {
+  return {
+    notify() {
+      // Notifications are only rendered in TUI mode.
+    },
+  }
+}
+
+function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
+  return {
+    notify(message: string, level?: NotificationLevel) {
+      const prefixedMessage = `${COMMAND_NAME}: ${message}`
+      ctx.ui.notify(prefixedMessage, level)
+    },
+  }
+}
+
+function createLoaderStatusReporter(loader: RequestyStatusLoader): StatusReporter {
+  return {
+    set(message: string) {
+      loader.setMessage(message)
+    },
+    clear() {
+      // Nothing to clear: the loader closes when ctx.ui.custom() resolves.
+    },
+  }
 }

package/src/ui/requesty-status-loader.ts

@@ -0,0 +1,38 @@
+import { DynamicBorder, Theme } from '@earendil-works/pi-coding-agent'
+import { Container, Loader, Spacer, TUI } from '@earendil-works/pi-tui'
+
+/**
+ * A loader that allows us to change the displayed message.
+ *
+ * @remarks
+ * this is essentially a reimplementation of the default BorderedLoader from pi-tui
+ * which does not offer a public api for changing its message.
+ */
+export class RequestyStatusLoader extends Container {
+  private readonly loader: Loader
+
+  constructor(tui: TUI, theme: Theme, message: string) {
+    super()
+
+    const borderColor = (s: string) => theme.fg('border', s)
+    this.loader = new Loader(
+      tui,
+      s => theme.fg('accent', s),
+      s => theme.fg('muted', s),
+      message,
+    )
+
+    this.addChild(new DynamicBorder(borderColor))
+    this.addChild(this.loader)
+    this.addChild(new Spacer(1))
+    this.addChild(new DynamicBorder(borderColor))
+  }
+
+  setMessage(message: string): void {
+    this.loader.setMessage(message)
+  }
+
+  dispose(): void {
+    this.loader.stop()
+  }
+}