pi-requesty-discover 1.1.0 → 2.0.0

package/README.adoc

@@ -16,7 +16,8 @@ This is a fork of https://github.com/requestyai/pi-requesty[pi-requesty] with ad
 
 * Use `REQUESTY_API_KEY` from the environment
 * Health-check available models and write a log about them
-* Provide a dry-run mode that does not change anything
+* Brief information about what was found, including added/removed models, health summary
+* Confirm before writing `models.json`, with a dry-run mode that only previews
 
 == When and why use it
 
@@ -25,7 +26,7 @@ Use this extension if
 - you are on Requesty.ai
 - you are limited to certain models by a company policy (for instance, for data residency/protection reasons)
 - you don't want to handcraft your own curated list of models constantly
-- you want to health check the list to complain about non-working models via a dry-run
+- you want to health-check models and preview the diff before writing
 
 == Installation
 
@@ -124,12 +125,20 @@ Inside Pi:
 /requesty-discover
 ----
 
-The command fetches Requesty models using `~/.pi/agent/models.json` and writes the discovered model IDs back to the same file.
-Run `/reload` after syncing.
+The command:
+
+- discovers Requesty models (and optional health checks)
+- shows a summary notification (added/removed IDs, health summary)
+- asks for confirmation before writing `~/.pi/agent/models.json`
+- reports whether the file was updated
+
+If there are no model ID changes, confirmation still offers a metadata refresh write, which might have changed as well.
+
+After a successful write, run `/reload`.
 
 [source,text]
 ----
 /requesty-discover --dry-run
 ----
 
-This will not overwrite the `models.json` file, but will do everything else, including the health checks.
+Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.

package/README.md

@@ -8,7 +8,8 @@ This is a fork of [pi-requesty](https://github.com/requestyai/pi-requesty) with
 
 * Use `REQUESTY_API_KEY` from the environment
 * Health-check available models and write a log about them
-* Provide a dry-run mode that does not change anything
+* Brief information about what was found, including added/removed models, health summary
+* Confirm before writing `models.json`, with a dry-run mode that only previews
 
 ## When and why use it
 
@@ -17,7 +18,7 @@ Use this extension if
 * you are on Requesty.ai
 * you are limited to certain models by a company policy (for instance, for data residency/protection reasons)
 * you don’t want to handcraft your own curated list of models constantly
-* you want to health check the list to complain about non-working models via a dry-run
+* you want to health-check models and preview the diff before writing
 
 ## Installation
 
@@ -91,11 +92,19 @@ Inside Pi:
 /requesty-discover
 ```
 
-The command fetches Requesty models using `~/.pi/agent/models.json` and writes the discovered model IDs back to the same file.
-Run `/reload` after syncing.
+The command:
+
+* discovers Requesty models (and optional health checks)
+* shows a summary notification (added/removed IDs, health summary)
+* asks for confirmation before writing `~/.pi/agent/models.json`
+* reports whether the file was updated
+
+If there are no model ID changes, confirmation still offers a metadata refresh write, which might have changed as well.
+
+After a successful write, run `/reload`.
 
 ```text
 /requesty-discover --dry-run
 ```
 
-This will not overwrite the `models.json` file, but will do everything else, including the health checks.
+Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",

package/src/health-check.ts

@@ -2,6 +2,7 @@ import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
 import fs from 'node:fs'
 import path from 'node:path'
 import { getEnv, type Env } from './env'
+import { formatModelsDiffSummary, type ModelsDiff } from './models-json'
 
 const HEALTH_CHECK_CONCURRENCY = 10
 const HEALTH_CHECK_TIMEOUT_MS = 15_000
@@ -98,7 +99,12 @@ export function formatHealthSummary(results: HealthCheckResult[]): string {
   return `Health check: ${passed.length} OK, ${failed.length} failed:\n${failedModels}\n`
 }
 
-export function writeHealthCheckLog(provider: Provider, results: HealthCheckResult[], envConfig: Env = getEnv()): void {
+export function writeHealthCheckLog(
+  provider: Provider,
+  results: HealthCheckResult[],
+  diff: ModelsDiff,
+  envConfig: Env = getEnv(),
+): void {
   const passed = results.filter(r => r.ok)
   const failed = results.filter(r => !r.ok)
   const lines = [
@@ -110,6 +116,8 @@ export function writeHealthCheckLog(provider: Provider, results: HealthCheckResu
     `Passed: ${passed.length}`,
     `Failed: ${failed.length}`,
     '',
+    formatModelsDiffSummary(diff),
+    '',
   ]
 
   if (failed.length === 0) {

package/src/index.ts

@@ -1,6 +1,12 @@
 import { ExtensionAPI, ExtensionCommandContext, ProviderModelConfig } from '@earendil-works/pi-coding-agent'
-import { getEnv } from './env'
-import { getRequestyConfig, updateModelsJson } from './models-json'
+import { type Env, getEnv } from './env'
+import {
+  diffModels,
+  formatModelsDiffSummary,
+  getRequestyConfig,
+  type ModelsDiff,
+  updateModelsJson,
+} from './models-json'
 import { discoverModels } from './requesty-api'
 import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
 import { RequestyStatusLoader } from './ui/requesty-status-loader.ts'
@@ -20,102 +26,214 @@ export type Notifier = {
   notify(message: string, level: NotificationLevel): void
 }
 
+export type Confirmer = {
+  confirm(title: string, message: string): Promise<boolean>
+}
+
 export type StatusReporter = {
   set(message: string): void
-  clear(): void
 }
 
+type ModelsJsonData = ReturnType<typeof getRequestyConfig>['data']
+
+type DiscoveryEvaluation = {
+  dryRun: boolean
+  modelCount: number
+  failedCount: number
+  passing: ProviderModelConfig[]
+  diff: ModelsDiff
+  healthCheckSummary: string
+  logNote: string
+  data: ModelsJsonData
+  env: Env
+}
+
+type EvaluationResult =
+  | {
+      ok: true
+      value: DiscoveryEvaluation
+    }
+  | { ok: false; error: unknown }
+
 // noinspection JSUnusedGlobalSymbols
 export default function (pi: ExtensionAPI) {
   pi.registerCommand(COMMAND_NAME, {
     description: 'Dynamically discover Requesty models, run health checks, and update the local models.json.',
     getArgumentCompletions,
     handler: async (args, ctx) => {
-      await runWithStatusUi(ctx, 'Discovering models...', (status, notifier) => runCommand(args, status, notifier))
+      await runDiscoveryWorkflow(ctx, args)
     },
   })
 }
 
+export async function runDiscoveryWorkflow(ctx: ExtensionCommandContext, args: string) {
+  // Interactive TUI command; no print/json/rpc path.
+  if (ctx.mode !== 'tui') {
+    return
+  }
+
+  const notifier = createUiNotifier(ctx)
+  const confirmer = createUiConfirmer(ctx)
+
+  // Phase A: progress UI only. Loader must close before confirm (Phase B).
+  // Errors are wrapped because ctx.ui.custom resolves via done() and does not reject.
+  const evaluationResult: EvaluationResult = await runWithStatusUi(ctx, 'Discovering models...', async status => {
+    try {
+      const evaluation = await evaluateDiscovery(args, status)
+      return { ok: true, value: evaluation }
+    } catch (error) {
+      return { ok: false, error }
+    }
+  })
+
+  if (!evaluationResult.ok) {
+    notifier.notify(formatDiscoveryFailure(evaluationResult.error), 'error')
+    return
+  }
+
+  // Phases B + C: decide, optional write, final notify — outside the loader.
+  await finalizeDiscovery(evaluationResult.value, confirmer, notifier)
+}
+
 async function runWithStatusUi<T>(
   ctx: ExtensionCommandContext,
   initialMessage: string,
-  fn: (status: StatusReporter, notifier: Notifier) => Promise<T>,
+  fn: (status: StatusReporter) => Promise<T>,
 ): Promise<T> {
-  if (ctx.mode !== 'tui') {
-    return fn(createNoopStatusReporter(), createNoopNotifier())
-  }
-
   return ctx.ui.custom<T>((_tui, theme, _kb, done) => {
     const loader = new RequestyStatusLoader(_tui, theme, initialMessage)
-    const notifier = createUiNotifier(ctx)
     const status = createLoaderStatusReporter(loader)
     void Promise.resolve()
-      .then(() => fn(status, notifier))
+      .then(() => fn(status))
       .then(done)
       .catch(done)
     return loader
   })
 }
 
-export async function runCommand(args: string, status: StatusReporter, notifier: Notifier): Promise<void> {
+function formatDiscoveryFailure(error: unknown): string {
+  const detail = error instanceof Error ? error.message : String(error)
+  return `Discovery failed: ${detail}`
+}
+
+async function evaluateDiscovery(args: string, status: StatusReporter): Promise<DiscoveryEvaluation> {
   status.set('Discovering Requesty models...')
-  const parts = args.split(' ')
-  const dryRun = parts.includes(DRY_RUN_ARG)
-  if (dryRun) {
-    notifier.notify('running in dry mode, no changes will be done', 'info')
+  const dryRun = args.split(' ').includes(DRY_RUN_ARG)
+
+  const env = getEnv()
+  const { data, provider, existingModelIds } = getRequestyConfig(env)
+  const models = await discoverModels(provider)
+  const modelsMap = new Map(models.map(m => [m.id, m]))
+
+  let diff: ModelsDiff
+  let failedCount = 0
+  let passing: ProviderModelConfig[]
+  let logNote = ''
+  let healthCheckSummary = ''
+
+  if (env.health_check_mode !== 'off') {
+    status.set(`Checking models 0/${models.length}...`)
+    const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
+      onProgress: ({ completed, total }) => {
+        status.set(`Checking models ${completed}/${total}...`)
+      },
+    })
+    const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
+    failedCount = sortedResults.filter(r => !r.ok).length
+    passing = sortedResults.flatMap(r => {
+      const model = modelsMap.get(r.modelId)
+      return r.ok && model ? [model] : []
+    })
+    diff = diffModels(existingModelIds, passing)
+    healthCheckSummary = formatHealthSummary(sortedResults)
+    writeHealthCheckLog(provider, sortedResults, diff, env)
+    logNote = `Full health check log: ${env.health_check_log_path}\n`
+  } else {
+    passing = models
+    diff = diffModels(existingModelIds, passing)
   }
 
-  try {
-    const env = getEnv()
-    const { data, provider } = getRequestyConfig(env)
-    const models = await discoverModels(provider)
-    const modelsMap = new Map(models.map(m => [m.id, m]))
-
-    let failed = []
-    let passing: ProviderModelConfig[]
-    let logNote = ''
-    let healthCheckSummary = ''
-
-    if (env.health_check_mode !== 'off') {
-      status.set(`Checking models 0/${models.length}...`)
-      const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
-        onProgress: ({ completed, total }) => {
-          status.set(`Checking models ${completed}/${total}...`)
-        },
-      })
-      const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
-      failed = sortedResults.filter(r => !r.ok)
-      passing = sortedResults.flatMap(r => {
-        const model = modelsMap.get(r.modelId)
-        return r.ok && model ? [model] : []
-      })
-      healthCheckSummary = formatHealthSummary(sortedResults)
-      writeHealthCheckLog(provider, sortedResults, env)
-      logNote = `Full health check log: ${env.health_check_log_path}\n`
-    } else {
-      passing = models
-    }
+  return {
+    dryRun,
+    modelCount: models.length,
+    failedCount,
+    passing,
+    diff,
+    healthCheckSummary,
+    logNote,
+    data,
+    env,
+  }
+}
 
-    const shouldUpdate = passing.length > 0 && !dryRun
-    if (shouldUpdate) {
-      updateModelsJson(data, passing, env)
-    }
+async function finalizeDiscovery(
+  evaluation: DiscoveryEvaluation,
+  confirmer: Confirmer,
+  notifier: Notifier,
+): Promise<void> {
+  const level = notificationLevel(evaluation)
+  const summary = buildDiscoverySummary(evaluation)
+
+  // Always surface the discovery result first (toast styling), then decide.
+  if (evaluation.dryRun) {
+    notifier.notify(
+      `${summary}
+Dry run: left models.json unchanged.`,
+      level,
+    )
+    return
+  }
+
+  if (evaluation.passing.length === 0) {
+    notifier.notify(
+      `${summary}
+Left models.json unchanged.`,
+      level,
+    )
+    return
+  }
+
+  notifier.notify(summary, level)
+  const { title, message } = buildConfirmPrompt(evaluation)
+  const shouldUpdate = await confirmer.confirm(title, message)
+  if (shouldUpdate) {
+    updateModelsJson(evaluation.data, evaluation.passing, evaluation.env)
+    notifier.notify('Updated models.json. Run /reload to use the changes.', 'info')
+    return
+  }
 
-    const writeNote = shouldUpdate ? 'Run /reload to use models.json changes.' : 'models.json was not updated.'
-    const message = `Discovered ${models.length} Requesty model(s).\n${healthCheckSummary}${logNote}${writeNote}`
+  notifier.notify('Left models.json unchanged.', 'info')
+}
 
-    if (failed.length === 0) {
-      notifier.notify(message, 'info')
-    } else if (failed.length < models.length) {
-      notifier.notify(message, 'warning')
-    } else {
-      notifier.notify(message, 'error')
+function buildDiscoverySummary(evaluation: DiscoveryEvaluation): string {
+  return [
+    `Discovered ${evaluation.modelCount} Requesty model(s).`,
+    evaluation.healthCheckSummary.trimEnd(),
+    formatModelsDiffSummary(evaluation.diff),
+    evaluation.logNote.trimEnd(),
+  ]
+    .filter(part => part.length > 0)
+    .join('\n')
+}
+
+function buildConfirmPrompt(evaluation: DiscoveryEvaluation): { title: string; message: string } {
+  const hasIdChanges = evaluation.diff.added.length > 0 || evaluation.diff.removed.length > 0
+  if (hasIdChanges) {
+    return {
+      title: `Write ${evaluation.passing.length} model(s)?`,
+      message: 'Update models.json with the discovery result above.',
     }
-  } catch (error) {
-    notifier.notify(`Discovery failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
-  } finally {
-    status.clear()
   }
+  return {
+    title: 'Refresh models.json?',
+    message: 'No model ID changes. Rewrite the file to refresh metadata anyway?',
+  }
+}
+
+function notificationLevel(evaluation: DiscoveryEvaluation): NotificationLevel {
+  if (evaluation.failedCount === 0) return 'info'
+  if (evaluation.failedCount < evaluation.modelCount) return 'warning'
+  return 'error'
 }
 
 function getArgumentCompletions(prefix: string): AutocompleteItem[] {
@@ -123,37 +241,26 @@ function getArgumentCompletions(prefix: string): AutocompleteItem[] {
     {
       value: DRY_RUN_ARG,
       label: DRY_RUN_ARG,
-      description: 'Preview without writing into the new model.json file',
+      description: 'Preview discovery without offering to write models.json',
     },
   ]
   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 createNoopNotifier(): Notifier {
+function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
   return {
-    notify() {
-      // Notifications are only rendered in TUI mode.
+    notify(message: string, level?: NotificationLevel) {
+      const prefixedMessage = `${COMMAND_NAME}: ${message}`
+      ctx.ui.notify(prefixedMessage, level)
     },
   }
 }
 
-function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
+function createUiConfirmer(ctx: ExtensionCommandContext): Confirmer {
   return {
-    notify(message: string, level?: NotificationLevel) {
-      const prefixedMessage = `${COMMAND_NAME}: ${message}`
-      ctx.ui.notify(prefixedMessage, level)
+    confirm(title, message) {
+      return ctx.ui.confirm(title, message)
     },
   }
 }
@@ -163,8 +270,5 @@ function createLoaderStatusReporter(loader: RequestyStatusLoader): StatusReporte
     set(message: string) {
       loader.setMessage(message)
     },
-    clear() {
-      // Nothing to clear: the loader closes when ctx.ui.custom() resolves.
-    },
   }
 }

package/src/models-json.ts

@@ -12,6 +12,7 @@ const ProviderSchema = z
     name: z.string().optional(),
     baseUrl: z.string().optional(),
     apiKey: z.string().optional(),
+    models: z.array(z.object({ id: z.string() }).catchall(z.unknown())).optional(),
   })
   .catchall(z.unknown())
 
@@ -33,6 +34,12 @@ type RequestyProvider = ModelsJsonProvider & {
 type RequestyConfig = {
   data: ModelsJson
   provider: RequestyProvider
+  existingModelIds: string[]
+}
+
+export type ModelsDiff = {
+  added: string[]
+  removed: string[]
 }
 
 export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
@@ -46,6 +53,7 @@ export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
   const apiKey = envConfig.requesty_api_key
   return {
     data,
+    existingModelIds: (provider.models ?? []).map(m => m.id),
     provider: {
       ...provider,
       name: nonEmptyString(provider.name) ?? DEFAULT_NAME,
@@ -55,6 +63,24 @@ export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
   }
 }
 
+export function diffModels(previousIds: string[], nextModels: ProviderModelConfig[]): ModelsDiff {
+  const previous = new Set(previousIds)
+  const next = new Set(nextModels.map(m => m.id))
+  return {
+    added: [...next].filter(id => !previous.has(id)).toSorted(),
+    removed: [...previous].filter(id => !next.has(id)).toSorted(),
+  }
+}
+
+export function formatModelsDiffSummary(diff: ModelsDiff): string {
+  return [
+    diff.added.length === 0 ? 'No added models.' : 'Added models:',
+    ...diff.added.map(id => `- ${id}`),
+    diff.removed.length === 0 ? 'No removed models.' : 'Removed models:',
+    ...diff.removed.map(id => `- ${id}`),
+  ].join('\n')
+}
+
 export function updateModelsJson(data: ModelsJson, models: ProviderModelConfig[], envConfig: Env = getEnv()): void {
   const provider = data.providers[envConfig.provider_id]
   data.providers[envConfig.provider_id] = {