@miaws/miaw 1.18.5 → 1.18.7

package/src/cli/cmd/run/question.shared.ts

@@ -1,340 +0,0 @@
-// Pure state machine for the question UI.
-//
-// Supports both single-question and multi-question flows. Single questions
-// submit immediately on selection. Multi-question flows use tabs and a
-// final confirmation step.
-//
-// State transitions:
-//   questionSelect  → picks an option (single: submits, multi: toggles/advances)
-//   questionSave    → saves custom text input
-//   questionMove    → arrow key navigation through options
-//   questionSetTab  → tab navigation between questions
-//   questionSubmit  → builds the final QuestionReply with all answers
-//
-// Custom answers: if a question has custom=true, an extra "Type your own
-// answer" option appears. Selecting it enters editing mode with a text field.
-import type { QuestionInfo, QuestionRequest } from "@miaw/sdk/v2"
-import type { QuestionReject, QuestionReply } from "./types"
-
-export type QuestionBodyState = {
-  requestID: string
-  tab: number
-  answers: string[][]
-  custom: string[]
-  selected: number
-  editing: boolean
-  submitting: boolean
-}
-
-export type QuestionStep = {
-  state: QuestionBodyState
-  reply?: QuestionReply
-}
-
-export function createQuestionBodyState(requestID: string): QuestionBodyState {
-  return {
-    requestID,
-    tab: 0,
-    answers: [],
-    custom: [],
-    selected: 0,
-    editing: false,
-    submitting: false,
-  }
-}
-
-export function questionSync(state: QuestionBodyState, requestID: string): QuestionBodyState {
-  if (state.requestID === requestID) {
-    return state
-  }
-
-  return createQuestionBodyState(requestID)
-}
-
-export function questionSingle(request: QuestionRequest): boolean {
-  return request.questions.length === 1 && request.questions[0]?.multiple !== true
-}
-
-export function questionTabs(request: QuestionRequest): number {
-  return questionSingle(request) ? 1 : request.questions.length + 1
-}
-
-export function questionConfirm(request: QuestionRequest, state: QuestionBodyState): boolean {
-  return !questionSingle(request) && state.tab === request.questions.length
-}
-
-export function questionInfo(request: QuestionRequest, state: QuestionBodyState): QuestionInfo | undefined {
-  return request.questions[state.tab]
-}
-
-export function questionCustom(request: QuestionRequest, state: QuestionBodyState): boolean {
-  return questionInfo(request, state)?.custom !== false
-}
-
-export function questionInput(state: QuestionBodyState): string {
-  return state.custom[state.tab] ?? ""
-}
-
-export function questionPicked(state: QuestionBodyState): boolean {
-  const value = questionInput(state)
-  if (!value) {
-    return false
-  }
-
-  return state.answers[state.tab]?.includes(value) ?? false
-}
-
-export function questionOther(request: QuestionRequest, state: QuestionBodyState): boolean {
-  const info = questionInfo(request, state)
-  if (!info || info.custom === false) {
-    return false
-  }
-
-  return state.selected === info.options.length
-}
-
-export function questionTotal(request: QuestionRequest, state: QuestionBodyState): number {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return 0
-  }
-
-  return info.options.length + (questionCustom(request, state) ? 1 : 0)
-}
-
-export function questionAnswers(state: QuestionBodyState, count: number): string[][] {
-  return Array.from({ length: count }, (_, idx) => state.answers[idx] ?? [])
-}
-
-export function questionSetTab(state: QuestionBodyState, tab: number): QuestionBodyState {
-  return {
-    ...state,
-    tab,
-    selected: 0,
-    editing: false,
-  }
-}
-
-export function questionSetSelected(state: QuestionBodyState, selected: number): QuestionBodyState {
-  return {
-    ...state,
-    selected,
-  }
-}
-
-export function questionSetEditing(state: QuestionBodyState, editing: boolean): QuestionBodyState {
-  return {
-    ...state,
-    editing,
-  }
-}
-
-export function questionSetSubmitting(state: QuestionBodyState, submitting: boolean): QuestionBodyState {
-  return {
-    ...state,
-    submitting,
-  }
-}
-
-function storeAnswers(state: QuestionBodyState, tab: number, list: string[]): QuestionBodyState {
-  const answers = [...state.answers]
-  answers[tab] = list
-  return {
-    ...state,
-    answers,
-  }
-}
-
-export function questionStoreCustom(state: QuestionBodyState, tab: number, text: string): QuestionBodyState {
-  const custom = [...state.custom]
-  custom[tab] = text
-  return {
-    ...state,
-    custom,
-  }
-}
-
-function questionPick(
-  state: QuestionBodyState,
-  request: QuestionRequest,
-  answer: string,
-  custom = false,
-): QuestionStep {
-  const answers = [...state.answers]
-  answers[state.tab] = [answer]
-  let next: QuestionBodyState = {
-    ...state,
-    answers,
-    editing: false,
-  }
-
-  if (custom) {
-    const list = [...state.custom]
-    list[state.tab] = answer
-    next = {
-      ...next,
-      custom: list,
-    }
-  }
-
-  if (questionSingle(request)) {
-    return {
-      state: next,
-      reply: {
-        requestID: request.id,
-        answers: [[answer]],
-      },
-    }
-  }
-
-  return {
-    state: questionSetTab(next, state.tab + 1),
-  }
-}
-
-function questionToggle(state: QuestionBodyState, answer: string): QuestionBodyState {
-  const list = [...(state.answers[state.tab] ?? [])]
-  const idx = list.indexOf(answer)
-  if (idx === -1) {
-    list.push(answer)
-  } else {
-    list.splice(idx, 1)
-  }
-
-  return storeAnswers(state, state.tab, list)
-}
-
-export function questionMove(state: QuestionBodyState, request: QuestionRequest, dir: -1 | 1): QuestionBodyState {
-  const total = questionTotal(request, state)
-  if (total === 0) {
-    return state
-  }
-
-  return {
-    ...state,
-    selected: (state.selected + dir + total) % total,
-  }
-}
-
-export function questionSelect(state: QuestionBodyState, request: QuestionRequest): QuestionStep {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return { state }
-  }
-
-  if (questionOther(request, state)) {
-    if (!info.multiple) {
-      return {
-        state: questionSetEditing(state, true),
-      }
-    }
-
-    const value = questionInput(state)
-    if (value && questionPicked(state)) {
-      return {
-        state: questionToggle(state, value),
-      }
-    }
-
-    return {
-      state: questionSetEditing(state, true),
-    }
-  }
-
-  const option = info.options[state.selected]
-  if (!option) {
-    return { state }
-  }
-
-  if (info.multiple) {
-    return {
-      state: questionToggle(state, option.label),
-    }
-  }
-
-  return questionPick(state, request, option.label)
-}
-
-export function questionSave(state: QuestionBodyState, request: QuestionRequest): QuestionStep {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return { state }
-  }
-
-  const value = questionInput(state).trim()
-  const prev = state.custom[state.tab]
-  if (!value) {
-    if (!prev) {
-      return {
-        state: questionSetEditing(state, false),
-      }
-    }
-
-    const next = questionStoreCustom(state, state.tab, "")
-    return {
-      state: questionSetEditing(
-        storeAnswers(
-          next,
-          state.tab,
-          (state.answers[state.tab] ?? []).filter((item) => item !== prev),
-        ),
-        false,
-      ),
-    }
-  }
-
-  if (info.multiple) {
-    const answers = [...(state.answers[state.tab] ?? [])]
-    if (prev) {
-      const idx = answers.indexOf(prev)
-      if (idx !== -1) {
-        answers.splice(idx, 1)
-      }
-    }
-
-    if (!answers.includes(value)) {
-      answers.push(value)
-    }
-
-    const next = questionStoreCustom(state, state.tab, value)
-    return {
-      state: questionSetEditing(storeAnswers(next, state.tab, answers), false),
-    }
-  }
-
-  return questionPick(state, request, value, true)
-}
-
-export function questionSubmit(request: QuestionRequest, state: QuestionBodyState): QuestionReply {
-  return {
-    requestID: request.id,
-    answers: questionAnswers(state, request.questions.length),
-  }
-}
-
-export function questionReject(request: QuestionRequest): QuestionReject {
-  return {
-    requestID: request.id,
-  }
-}
-
-export function questionHint(request: QuestionRequest, state: QuestionBodyState): string {
-  if (state.submitting) {
-    return "Waiting for question event..."
-  }
-
-  if (questionConfirm(request, state)) {
-    return "enter submit   esc dismiss"
-  }
-
-  if (state.editing) {
-    return "enter save   esc cancel"
-  }
-
-  const info = questionInfo(request, state)
-  if (questionSingle(request)) {
-    return `↑↓ select   enter ${info?.multiple ? "toggle" : "submit"}   esc dismiss`
-  }
-
-  return `⇆ tab   ↑↓ select   enter ${info?.multiple ? "toggle" : "confirm"}   esc dismiss`
-}

package/src/cli/cmd/run/runtime.boot.ts

@@ -1,202 +0,0 @@
-// Boot-time resolution for direct interactive mode.
-//
-// These functions run concurrently at startup to gather everything the runtime
-// needs before the first frame: TUI keymap config, diff display style,
-// model variant list with context limits, and session history for the prompt
-// history ring. All are async because they read config or hit the SDK, but
-// none block each other.
-import { Context, Effect, Layer } from "effect"
-import { resolve } from "@miaw/tui/config"
-import { TuiConfig } from "@/config/tui"
-import { makeRuntime } from "@/effect/run-service"
-import { reusePendingTask } from "./runtime.shared"
-import { resolveSession, sessionHistory } from "./session.shared"
-import type { RunDiffStyle, RunInput, RunPrompt, RunProvider, RunTuiConfig } from "./types"
-import { pickVariant } from "./variant.shared"
-
-export type ModelInfo = {
-  providers: RunProvider[]
-  variants: string[]
-  limits: Record<string, number>
-}
-
-export type SessionInfo = {
-  first: boolean
-  history: RunPrompt[]
-  variant: string | undefined
-}
-
-type Config = Awaited<ReturnType<typeof TuiConfig.get>>
-type BootService = {
-  readonly resolveModelInfo: (
-    sdk: RunInput["sdk"],
-    directory: string,
-    model: RunInput["model"],
-  ) => Effect.Effect<ModelInfo>
-  readonly resolveSessionInfo: (
-    sdk: RunInput["sdk"],
-    sessionID: string,
-    model: RunInput["model"],
-  ) => Effect.Effect<SessionInfo>
-  readonly resolveRunTuiConfig: () => Effect.Effect<RunTuiConfig>
-  readonly resolveDiffStyle: () => Effect.Effect<RunDiffStyle>
-}
-
-const configTask: { current?: Promise<Config> } = {}
-
-class Service extends Context.Service<Service, BootService>()("@miaw/RunBoot") {}
-
-function loadConfig() {
-  return reusePendingTask(configTask, () => TuiConfig.get())
-}
-
-function emptyModelInfo(): ModelInfo {
-  return {
-    providers: [],
-    variants: [],
-    limits: {},
-  }
-}
-
-function emptySessionInfo(): SessionInfo {
-  return {
-    first: true,
-    history: [],
-    variant: undefined,
-  }
-}
-
-function defaultRunTuiConfig(): RunTuiConfig {
-  return {
-    ...resolve({}, { terminalSuspend: process.platform !== "win32" }),
-    diff_style: "auto",
-  }
-}
-
-function runTuiConfig(config: Config | undefined): RunTuiConfig {
-  if (!config) {
-    return defaultRunTuiConfig()
-  }
-
-  return {
-    keybinds: config.keybinds,
-    leader_timeout: config.leader_timeout,
-    diff_style: config.diff_style ?? "auto",
-  }
-}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = Effect.fn("RunBoot.config")(() => Effect.promise(() => loadConfig().catch(() => undefined)))
-
-    const resolveModelInfo = Effect.fn("RunBoot.resolveModelInfo")(function* (
-      sdk: RunInput["sdk"],
-      directory: string,
-      model: RunInput["model"],
-    ) {
-      const connected = yield* Effect.promise(() =>
-        sdk.config
-          .providers({ directory })
-          .then((item) => item.data?.providers)
-          .catch(() => undefined),
-      )
-      const providers = yield* Effect.promise(() =>
-        connected
-          ? Promise.resolve(connected)
-          : sdk.provider
-              .list()
-              .then((item) => item.data?.all ?? [])
-              .catch(() => []),
-      )
-      const limits = Object.fromEntries(
-        providers.flatMap((provider) =>
-          Object.entries(provider.models ?? {}).flatMap(([modelID, info]) => {
-            const limit = info?.limit?.context
-            if (typeof limit !== "number" || limit <= 0) {
-              return []
-            }
-
-            return [[`${provider.id}/${modelID}`, limit] as const]
-          }),
-        ),
-      )
-
-      if (!model) {
-        return {
-          providers,
-          variants: [],
-          limits,
-        }
-      }
-
-      const info = providers.find((item) => item.id === model.providerID)?.models?.[model.modelID]
-      return {
-        providers,
-        variants: Object.keys(info?.variants ?? {}),
-        limits,
-      }
-    })
-
-    const resolveSessionInfo = Effect.fn("RunBoot.resolveSessionInfo")(function* (
-      sdk: RunInput["sdk"],
-      sessionID: string,
-      model: RunInput["model"],
-    ) {
-      const session = yield* Effect.promise(() => resolveSession(sdk, sessionID).catch(() => undefined))
-      if (!session) {
-        return emptySessionInfo()
-      }
-
-      return {
-        first: session.first,
-        history: sessionHistory(session),
-        variant: pickVariant(model, session),
-      }
-    })
-
-    const resolveRunTuiConfig = Effect.fn("RunBoot.resolveRunTuiConfig")(function* () {
-      return runTuiConfig(yield* config())
-    })
-
-    const resolveDiffStyle = Effect.fn("RunBoot.resolveDiffStyle")(function* () {
-      return runTuiConfig(yield* config()).diff_style ?? "auto"
-    })
-
-    return Service.of({
-      resolveModelInfo,
-      resolveSessionInfo,
-      resolveRunTuiConfig,
-      resolveDiffStyle,
-    })
-  }),
-)
-
-const runtime = makeRuntime(Service, layer)
-
-// Fetches available variants and context limits for every provider/model pair.
-export async function resolveModelInfo(
-  sdk: RunInput["sdk"],
-  directory: string,
-  model: RunInput["model"],
-): Promise<ModelInfo> {
-  return runtime.runPromise((svc) => svc.resolveModelInfo(sdk, directory, model)).catch(() => emptyModelInfo())
-}
-
-// Fetches session messages to determine if this is the first turn and build prompt history.
-export async function resolveSessionInfo(
-  sdk: RunInput["sdk"],
-  sessionID: string,
-  model: RunInput["model"],
-): Promise<SessionInfo> {
-  return runtime.runPromise((svc) => svc.resolveSessionInfo(sdk, sessionID, model)).catch(() => emptySessionInfo())
-}
-
-// Reads TUI config once for direct mode keymap setup and display preferences.
-export async function resolveRunTuiConfig(): Promise<RunTuiConfig> {
-  return runtime.runPromise((svc) => svc.resolveRunTuiConfig()).catch(() => defaultRunTuiConfig())
-}
-
-export async function resolveDiffStyle(): Promise<RunDiffStyle> {
-  return runtime.runPromise((svc) => svc.resolveDiffStyle()).catch(() => "auto")
-}