@xp266/dshtui 0.1.0

package/src/chat/models.ts

@@ -0,0 +1,263 @@
+import type { LlmDiscoveredModel } from '@deepseek-ai/dsh-llm'
+import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
+
+export interface ConfiguredModel {
+  id: string
+  name: string
+  provider: string
+  providerName: string
+}
+
+export type ModelEffortKey = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'
+
+export interface ModelEntryConfig {
+  id: string
+  name?: string
+  contextWindow?: number
+  maxTokens?: number
+  input?: string[]
+  reasoningEfforts?: false | Partial<Record<ModelEffortKey, string | null>>
+}
+
+export interface DescribedModel {
+  name: string
+  contextWindow?: number
+  image: boolean
+}
+
+export interface CustomProviderForm {
+  providerId: string
+  displayName: string
+  apiUrl: string
+  apiProtocol: string
+  apiKey: string
+}
+
+export interface OfficialProvider {
+  provider: string
+  displayName: string
+  settingsNs: string
+  settingsPath: readonly string[]
+  declared?: boolean
+}
+
+export const API_PROTOCOLS = ['openai-completions', 'openai-responses', 'anthropic-messages']
+
+export const PI_AI_SETTINGS_NS = 'llm-pi-ai'
+export async function listConfiguredModels(llm: Pick<LlmRuntime, 'listProviders' | 'listModels'>): Promise<ConfiguredModel[]> {
+  const models: ConfiguredModel[] = []
+  for (const provider of llm.listProviders()) {
+    const list = await llm.listModels(provider.id)
+    for (const model of list) {
+      models.push({ id: model.id, name: model.name ?? model.id, provider: provider.id, providerName: provider.name })
+    }
+  }
+  return models
+}
+
+export function listProviderDirectory(llm: Pick<LlmRuntime, 'listConfigurableProviders'>): OfficialProvider[] {
+  return llm.listConfigurableProviders().map(entry => ({
+    provider: entry.provider,
+    displayName: entry.displayName,
+    settingsNs: entry.settingsNs,
+    settingsPath: entry.settingsPath,
+    ...(entry.declared === undefined ? {} : { declared: entry.declared }),
+  }))
+}
+
+export interface KeyStorer {
+  set(ref: string, value: string): Promise<void>
+}
+
+export interface ModelFetcher {
+  discoverModels(
+    ns: string,
+    request: { provider?: string; baseURL?: string; api?: string; apiKey?: string; signal?: AbortSignal },
+  ): Promise<LlmDiscoveredModel[]>
+}
+
+const DISCOVERY_TIMEOUT_MS = 15000
+
+export async function fetchCustomModels(fetcher: ModelFetcher, form: CustomProviderForm): Promise<LlmDiscoveredModel[]> {
+  return fetcher.discoverModels(PI_AI_SETTINGS_NS, {
+    baseURL: form.apiUrl,
+    api: form.apiProtocol,
+    apiKey: form.apiKey,
+    signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS),
+  })
+}
+
+export async function fetchProviderModels(fetcher: ModelFetcher, settingsNs: string, providerId: string, apiKey: string): Promise<LlmDiscoveredModel[]> {
+  return fetcher.discoverModels(settingsNs, {
+    provider: providerId,
+    ...(apiKey.length > 0 ? { apiKey } : {}),
+    signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS),
+  })
+}
+
+export interface SettingsWriter {
+  update(ns: string, patch: unknown, expectedRevision?: number | null): Promise<unknown>
+}
+
+function storedModels(models: LlmDiscoveredModel[]): Array<Record<string, unknown>> {
+  return models.map(model => ({
+    id: model.id,
+    ...(model.name === undefined ? {} : { name: model.name }),
+    ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow }),
+    ...(model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens }),
+  }))
+}
+
+export async function saveCustomProvider(
+  write: SettingsWriter,
+  store: KeyStorer,
+  form: CustomProviderForm,
+  models: LlmDiscoveredModel[],
+): Promise<void> {
+  const keyRef = providerKeyRef(form.providerId)
+  if (form.apiKey.length > 0) await store.set(keyRef, form.apiKey)
+  await write.update(PI_AI_SETTINGS_NS, {
+    providers: {
+      [form.providerId]: {
+        displayName: form.displayName || form.providerId,
+        api: form.apiProtocol,
+        baseURL: form.apiUrl,
+        ...(form.apiKey.length > 0 ? { apiKeyEnv: keyRef } : {}),
+        models: storedModels(models),
+      },
+    },
+  })
+}
+
+function patchAtPath(patch: object, path: readonly string[]): object {
+  const root: Record<string, unknown> = {}
+  let cursor = root
+  for (const segment of path) {
+    const next: Record<string, unknown> = {}
+    cursor[segment] = next
+    cursor = next
+  }
+  Object.assign(cursor, patch)
+  return root
+}
+
+export async function saveProviderKey(
+  write: SettingsWriter,
+  store: KeyStorer,
+  provider: OfficialProvider,
+  apiKey: string,
+): Promise<void> {
+  if (apiKey.trim() === '') throw new Error('API key must not be empty')
+  const keyRef = providerKeyRef(provider.provider)
+  await store.set(keyRef, apiKey)
+  await write.update(provider.settingsNs, patchAtPath({ apiKeyEnv: keyRef }, provider.settingsPath))
+}
+
+export async function saveProviderModels(
+  write: SettingsWriter,
+  provider: OfficialProvider,
+  models: LlmDiscoveredModel[],
+): Promise<void> {
+  await write.update(provider.settingsNs, patchAtPath({ models: storedModels(models) }, provider.settingsPath))
+}
+
+const KEY_REF_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/
+const PROVIDER_ID_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*$/
+
+export function isProviderIdValid(providerId: string): boolean {
+  return PROVIDER_ID_PATTERN.test(providerId)
+}
+
+export function providerKeyRef(providerId: string): string {
+  const ref = `${providerId.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}_API_KEY`
+  if (!KEY_REF_PATTERN.test(ref)) {
+    throw new Error(`provider id "${providerId}" produces invalid credential ref "${ref}"; use a name starting with a letter`)
+  }
+  return ref
+}
+
+export interface SettingsReader {
+  get(ns: string): unknown
+}
+
+function providerSection(reader: SettingsReader, ns: string, provider: string): Record<string, unknown> | undefined {
+  const section = reader.get(ns)
+  if (section === undefined || typeof section !== 'object') return undefined
+  const providers = (section as { providers?: Record<string, unknown> }).providers
+  if (providers === undefined || typeof providers !== 'object') return undefined
+  const profile = providers[provider]
+  if (profile === undefined || typeof profile !== 'object') return undefined
+  return profile as Record<string, unknown>
+}
+
+export function readModelEntries(reader: SettingsReader, ns: string, provider: string): ModelEntryConfig[] {
+  const profile = providerSection(reader, ns, provider)
+  const models = profile?.models
+  if (!Array.isArray(models)) return []
+  return models.filter((entry): entry is ModelEntryConfig =>
+    typeof entry === 'object' && entry !== null && typeof (entry as ModelEntryConfig).id === 'string')
+}
+
+export async function saveModelEntry(
+  write: SettingsWriter,
+  reader: SettingsReader,
+  ns: string,
+  provider: string,
+  entry: ModelEntryConfig,
+): Promise<void> {
+  const models = readModelEntries(reader, ns, provider)
+  const index = models.findIndex(model => model.id === entry.id)
+  const next = [...models]
+  if (index >= 0) next[index] = entry
+  else next.push(entry)
+  await write.update(ns, { providers: { [provider]: { models: next } } })
+}
+
+export async function deleteModelEntry(
+  write: SettingsWriter,
+  reader: SettingsReader,
+  ns: string,
+  provider: string,
+  modelId: string,
+): Promise<void> {
+  const models = readModelEntries(reader, ns, provider)
+  const next = models.filter(model => model.id !== modelId)
+  if (next.length === models.length) return
+  await write.update(ns, { providers: { [provider]: { models: next } } })
+}
+
+export type SettingsPathOp =
+  | { op: 'set'; path: readonly string[]; value: unknown }
+  | { op: 'unset'; path: readonly string[] }
+
+export interface SettingsMutator {
+  get(ns: string): unknown
+  mutate(ns: string, ops: readonly SettingsPathOp[]): Promise<void>
+}
+
+export interface KeyRemover {
+  unset(ref: string): Promise<void>
+  describe(ref: string): Promise<{ configured: boolean; writable: boolean }>
+}
+
+/**
+ * Delete one adapter-declared provider profile through the harness's official
+ * write path: path-addressed `unset` on the owning settings namespace, plus
+ * credential removal when the profile stores its key under the conventional
+ * managed reference. Mirrors the web bundle's removeProviderProfile.
+ */
+export async function deleteProviderProfile(
+  settings: SettingsMutator,
+  store: KeyRemover,
+  provider: OfficialProvider,
+): Promise<void> {
+  if (provider.declared !== true) throw new Error('only custom providers can be deleted')
+  const managedRef = providerKeyRef(provider.provider)
+  const profile = providerSection(settings, provider.settingsNs, provider.provider)
+  const apiKeyEnv = typeof profile?.apiKeyEnv === 'string' ? profile.apiKeyEnv : undefined
+  if (apiKeyEnv === managedRef) {
+    const info = await store.describe(managedRef).catch(() => undefined)
+    if (info?.configured === true && info.writable) await store.unset(managedRef)
+  }
+  await settings.mutate(provider.settingsNs, [{ op: 'unset', path: [...provider.settingsPath] }])
+}

package/src/chat/partial-json.ts

@@ -0,0 +1,125 @@
+export interface PartialField {
+  value: string
+  complete: boolean
+}
+
+export type PartialFields = Record<string, PartialField>
+
+export function extractPartialJsonFields(raw: string): PartialFields {
+  const out: PartialFields = {}
+  const source = raw
+  const end = source.length
+  let i = 0
+  while (i < end && source[i] !== '{') i++
+  if (i >= end) return out
+  i++
+  while (i < end) {
+    while (i < end && (source[i] === ' ' || source[i] === '\n' || source[i] === '\r' || source[i] === '\t' || source[i] === ',')) i++
+    if (i < end && source[i] === '}') break
+    if (i >= end || source[i] !== '"') {
+      i++
+      continue
+    }
+    i++
+    const keyStart = i
+    while (i < end && source[i] !== '"') {
+      if (source[i] === '\\') i++
+      i++
+    }
+    if (i >= end) break
+    const key = unescapePartial(source.slice(keyStart, i))
+    i++
+    while (i < end && (source[i] === ' ' || source[i] === '\n' || source[i] === '\r' || source[i] === '\t')) i++
+    if (i >= end || source[i] !== ':') continue
+    i++
+    while (i < end && (source[i] === ' ' || source[i] === '\n' || source[i] === '\r' || source[i] === '\t')) i++
+    if (i >= end) {
+      out[key] = { value: '', complete: false }
+      break
+    }
+    if (source[i] === '"') {
+      i++
+      const valueStart = i
+      let closed = false
+      while (i < end) {
+        const ch = source[i]
+        if (ch === '\\') {
+          i += 2
+          continue
+        }
+        if (ch === '"') {
+          closed = true
+          break
+        }
+        i++
+      }
+      out[key] = { value: unescapePartial(source.slice(valueStart, Math.min(i, end))), complete: closed }
+      i++
+      continue
+    }
+    const valueStart = i
+    let depth = 0
+    while (i < end) {
+      const ch = source[i]
+      if (ch === '"') {
+        i++
+        while (i < end && source[i] !== '"') {
+          if (source[i] === '\\') i++
+          i++
+        }
+        i++
+        continue
+      }
+      if (ch === '{' || ch === '[') depth++
+      else if (ch === '}' || ch === ']') {
+        if (depth === 0) break
+        depth--
+      } else if (ch === ',' && depth === 0) break
+      i++
+    }
+    out[key] = { value: source.slice(valueStart, i).trim(), complete: i < end && (source[i] === ',' || source[i] === '}') }
+  }
+  return out
+}
+
+export function unescapePartial(text: string): string {
+  if (!text.includes('\\')) return text
+  let out = ''
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    if (ch !== '\\') {
+      out += ch
+      continue
+    }
+    const next = text[i + 1]
+    if (next === undefined) break
+    switch (next) {
+      case 'n': out += '\n'; i++; break
+      case 't': out += '\t'; i++; break
+      case 'r': out += '\r'; i++; break
+      case 'b': out += '\b'; i++; break
+      case 'f': out += '\f'; i++; break
+      case '/': out += '/'; i++; break
+      case '"': out += '"'; i++; break
+      case "'": out += "'"; i++; break
+      case '\\': out += '\\'; i++; break
+      case 'u': {
+        const hex = text.slice(i + 2, i + 6)
+        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+          out += String.fromCharCode(Number.parseInt(hex, 16))
+          i += 5
+        } else if (/^[0-9a-fA-F]{0,3}$/.test(hex)) {
+          return out
+        } else {
+          out += next
+          i++
+        }
+        break
+      }
+      default:
+        out += next
+        i++
+    }
+  }
+  return out
+}

package/src/chat/presets.ts

@@ -0,0 +1,26 @@
+import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+
+const BUILT_IN_NAMES: Readonly<Record<string, string>> = {
+  standard: 'Standard mode',
+  code: 'Code mode',
+  minimal: 'Minimal mode',
+  cordis: 'Creator mode',
+}
+
+export interface PresetSummary {
+  id: string
+  name: string
+}
+
+export function builtInPresetName(id: string): string | undefined {
+  return BUILT_IN_NAMES[id]
+}
+
+export function presetDisplayName(preset: AgentPreset): string {
+  return BUILT_IN_NAMES[preset.id] ?? preset.name ?? preset.id
+}
+
+export function isBlankSession(events: readonly SessionEvent[]): boolean {
+  return !events.some(event => event.type === 'turn/start')
+}

package/src/chat/question-view.ts

@@ -0,0 +1,106 @@
+import type { AskOptionLike, AskQuestionItemLike, AskUserQuestionAnswerItemLike } from './interactions.ts'
+
+export const ASK_USER_TOOL_NAME = 'ask_user_question'
+
+const ANSWER_INDENT = 3
+const UNANSWERED_TEXT = '(Question not answered)'
+
+export function answerSummary(
+  question: AskQuestionItemLike,
+  selected: readonly string[],
+  custom: string,
+  customChecked: boolean,
+): string {
+  if (customChecked && custom !== '') {
+    return question.multiSelect === true && selected.length > 0
+      ? [...selected, custom].join(', ')
+      : custom
+  }
+  return selected.length === 0 ? UNANSWERED_TEXT : selected.join(', ')
+}
+
+export function parseAskQuestions(raw: unknown): AskQuestionItemLike[] {
+  if (typeof raw !== 'object' || raw === null) return []
+  const questions = (raw as { questions?: unknown }).questions
+  if (!Array.isArray(questions)) return []
+  return questions.map(questionFromJson).filter(question => question !== undefined)
+}
+
+export function parseAskAnswers(resultText: string): AskUserQuestionAnswerItemLike[] {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(resultText)
+  } catch {
+    // A non-JSON result text simply carries no answers.
+    return []
+  }
+  if (typeof parsed !== 'object' || parsed === null) return []
+  const answers = (parsed as { answers?: unknown }).answers
+  if (!Array.isArray(answers)) return []
+  return answers.map(answerFromJson).filter(answer => answer !== undefined)
+}
+
+function answerTextOf(question: AskQuestionItemLike, answer: AskUserQuestionAnswerItemLike | undefined): string {
+  if (answer === undefined) return UNANSWERED_TEXT
+  const custom = answer.custom?.trim() ?? ''
+  return answerSummary(question, answer.selected, custom, custom !== '')
+}
+
+function questionFromJson(value: unknown): AskQuestionItemLike | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as Record<string, unknown>
+  if (typeof record.id !== 'string' || typeof record.question !== 'string') return undefined
+  const multiSelect = record.multiSelect === true || record.multi_select === true
+  return {
+    id: record.id,
+    question: record.question,
+    ...(typeof record.header === 'string' && record.header !== '' ? { header: record.header } : {}),
+    ...(typeof record.detail === 'string' && record.detail !== '' ? { detail: record.detail } : {}),
+    ...(Array.isArray(record.options) ? { options: record.options.map(optionFromJson).filter(option => option !== undefined) } : {}),
+    ...(multiSelect ? { multiSelect } : {}),
+  }
+}
+
+function optionFromJson(value: unknown): AskOptionLike | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as Record<string, unknown>
+  if (typeof record.label !== 'string') return undefined
+  return { label: record.label }
+}
+
+function answerFromJson(value: unknown): AskUserQuestionAnswerItemLike | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as Record<string, unknown>
+  if (typeof record.id !== 'string' || !Array.isArray(record.selected)) return undefined
+  const selected = record.selected.filter(label => typeof label === 'string')
+  return {
+    id: record.id,
+    selected,
+    ...(typeof record.custom === 'string' ? { custom: record.custom } : {}),
+  }
+}
+
+/** The ask questions rendered as numbered entries with their options, used
+ *  as the card args area (the original question formatting without the
+ *  tool-name title line). */
+export function formatAskQuestions(raw: unknown): string {
+  const questions = parseAskQuestions(raw)
+  if (questions.length === 0) return ''
+  return questions.map((question, index) => {
+    const lines = [`${index + 1}. ${question.question}`]
+    if (question.detail !== undefined && question.detail !== '') lines.push(`${' '.repeat(ANSWER_INDENT)}${question.detail}`)
+    for (const option of question.options ?? []) lines.push(`${' '.repeat(ANSWER_INDENT)}${option.label}`)
+    return lines.join('\n')
+  }).join('\n')
+}
+
+/** The settled ask card: each question followed by the user's choice. */
+export function formatAskAnswered(
+  questions: readonly AskQuestionItemLike[],
+  answers: readonly AskUserQuestionAnswerItemLike[],
+): string {
+  return questions.map((question, index) => {
+    const answer = answers.find(entry => entry.id === question.id)
+    return `${index + 1}. ${question.question}\n${' '.repeat(ANSWER_INDENT)}${answerTextOf(question, answer)}`
+  }).join('\n')
+}

package/src/chat/retry-status.ts

@@ -0,0 +1,33 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+
+export interface RetryStatus {
+  attempt: number
+  maxRetries: number
+  untilTs: number
+  code: string
+}
+
+interface RetryEventData {
+  retry: number
+  maxRetries?: number
+  delayMs?: number
+  failure?: { code?: string }
+}
+
+export function nextRetryStatus(current: RetryStatus | undefined, event: SessionEvent): RetryStatus | undefined {
+  const type = event.type as string
+  if (type === 'llm/retry') {
+    const data = event.data as unknown as RetryEventData
+    return {
+      attempt: data.retry,
+      maxRetries: data.maxRetries ?? data.retry,
+      untilTs: Date.now() + Math.max(0, data.delayMs ?? 0),
+      code: data.failure?.code ?? 'UNKNOWN',
+    }
+  }
+  if (type === 'llm/retry-started') {
+    return current === undefined ? undefined : { ...current, untilTs: 0 }
+  }
+  if (event.type === 'assistant/chunk' || event.type === 'turn/end') return undefined
+  return current
+}

package/src/chat/session-groups.ts

@@ -0,0 +1,34 @@
+import type { SessionSummary } from './session-list.ts'
+import { sessionTime } from './session-list.ts'
+
+export type SessionSectionKind = 'recent' | 'week' | 'older'
+
+export interface SessionSection {
+  kind: SessionSectionKind
+  items: SessionSummary[]
+}
+
+const RECENT_LIMIT = 5
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000
+
+function startOfDay(now: number): number {
+  const date = new Date(now)
+  date.setHours(0, 0, 0, 0)
+  return date.getTime()
+}
+
+export function groupSessions(items: readonly SessionSummary[], now: number = Date.now()): SessionSection[] {
+  const sorted = [...items].sort((a, b) => sessionTime(b) - sessionTime(a))
+  if (sorted.length === 0) return []
+  const sections: SessionSection[] = [{ kind: 'recent', items: sorted.slice(0, RECENT_LIMIT) }]
+  const weekStart = startOfDay(now) - WEEK_MS
+  const buckets: Record<Exclude<SessionSectionKind, 'recent'>, SessionSummary[]> = { week: [], older: [] }
+  for (const session of sorted) {
+    if (sessionTime(session) >= weekStart) buckets.week.push(session)
+    else buckets.older.push(session)
+  }
+  for (const kind of ['week', 'older'] as const) {
+    if (buckets[kind].length > 0) sections.push({ kind, items: buckets[kind] })
+  }
+  return sections
+}