@fonlan/dsh-task-kanban 0.1.1 → 0.2.1

package/src/client/sections.tsx

@@ -1,8 +1,8 @@
-import { useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { IconChecklistOutline14 } from '@deepseek-ai/dsh-client-ui-primitives'
-import { api } from './api'
+import { api, type PresetOption, type ReasoningOptions } from './api'
 import { toggleBoard, useBoardOpen } from './kanban-state'
-import type { KanbanSettingsShape } from '../shared/card'
+import type { KanbanSettingsShape, ModelOption } from '../shared/card'
 
 interface FooterActionProps {
   wide?: boolean
@@ -140,17 +140,141 @@ export function KanbanFooterButton({ wide, t }: FooterActionProps): JSX.Element
   )
 }
 
-interface SettingsSectionProps {
+interface SettingsCardProps {
   t?: (key: string) => string
 }
 
-/** Plugin settings section: global parallel workers + default model. */
-export function KanbanSettingsSection({ t }: SettingsSectionProps): JSX.Element {
+/** Fallback shape while settings load (server always resolves the full set). */
+const EMPTY_SETTINGS: KanbanSettingsShape = {
+  maxParallelWorkers: 1,
+  refinementModel: '',
+  refinementProvider: '',
+  refinementReasoningEffort: '',
+  refinementPreset: '',
+  phaseModel: '',
+  phaseProvider: '',
+  phaseReasoningEffort: '',
+  phasePreset: '',
+}
+
+/** The setting field names of one session-type group. */
+const GROUP_FIELDS = {
+  refinement: {
+    model: 'refinementModel',
+    provider: 'refinementProvider',
+    effort: 'refinementReasoningEffort',
+    preset: 'refinementPreset',
+  },
+  phase: {
+    model: 'phaseModel',
+    provider: 'phaseProvider',
+    effort: 'phaseReasoningEffort',
+    preset: 'phasePreset',
+  },
+} as const
+
+type SessionGroupKey = keyof typeof GROUP_FIELDS
+
+interface SessionDefaultsGroupProps {
+  kind: SessionGroupKey
+  settings: KanbanSettingsShape
+  models: ModelOption[]
+  presets: PresetOption[]
+  /** Reasoning efforts already fetched, keyed `provider/model`. */
+  efforts: Record<string, ReasoningOptions>
+  tr: (key: string) => string
+  onCommit: (patch: Partial<KanbanSettingsShape>) => Promise<void>
+  loadEfforts: (provider: string, model: string) => void
+}
+
+/** Model / reasoning effort / agent preset defaults for one session type. */
+function SessionDefaultsGroup({ kind, settings, models, presets, efforts, tr, onCommit, loadEfforts }: SessionDefaultsGroupProps): JSX.Element {
+  const fields = GROUP_FIELDS[kind]
+  const model = settings[fields.model]
+  const provider = settings[fields.provider]
+  const effort = settings[fields.effort]
+  const preset = settings[fields.preset]
+  const effortKey = model !== '' && provider !== '' ? `${provider}/${model}` : ''
+  const effortOptions = effortKey !== '' ? (efforts[effortKey]?.efforts ?? []) : []
+
+  const handleModel = (id: string): void => {
+    const found = models.find((m) => m.id === id)
+    const nextProvider = found?.provider ?? ''
+    void onCommit({ [fields.model]: id, [fields.provider]: nextProvider } as Partial<KanbanSettingsShape>)
+    if (id !== '' && nextProvider !== '') loadEfforts(nextProvider, id)
+  }
+
+  return (
+    <div className="kb-settings-group">
+      <div className="kb-settings-group-title">{tr(kind === 'refinement' ? 'settingsRefineGroup' : 'settingsPhaseGroup')}</div>
+      <label className="kb-field kb-field-row">
+        <span>{tr('model')}</span>
+        <select className="kb-input" value={model} onChange={(e) => handleModel(e.target.value)}>
+          <option value="">{tr('defaultOption')}</option>
+          {models.map((m) => (
+            <option key={m.provider + '/' + m.id} value={m.id}>{m.name ?? m.id}</option>
+          ))}
+        </select>
+      </label>
+      <label className="kb-field kb-field-row">
+        <span>{tr('reasoningEffort')}</span>
+        <select
+          className="kb-input"
+          value={effort}
+          disabled={model === ''}
+          onChange={(e) => void onCommit({ [fields.effort]: e.target.value } as Partial<KanbanSettingsShape>)}
+        >
+          <option value="">{tr('defaultOption')}</option>
+          {effortOptions.map((o) => (
+            <option key={o.id} value={o.id}>{o.name}</option>
+          ))}
+        </select>
+      </label>
+      <label className="kb-field kb-field-row">
+        <span>{tr('agentPreset')}</span>
+        <select
+          className="kb-input"
+          value={preset}
+          onChange={(e) => void onCommit({ [fields.preset]: e.target.value } as Partial<KanbanSettingsShape>)}
+        >
+          <option value="">{tr('defaultOption')}</option>
+          {presets.map((p) => (
+            <option key={p.id} value={p.id}>{p.name ?? p.id}</option>
+          ))}
+        </select>
+      </label>
+    </div>
+  )
+}
+
+/** Plugin settings card (设置 → 插件配置): workers + default model + per-session-type defaults. */
+export function KanbanSettingsCard({ t }: SettingsCardProps): JSX.Element {
   const tr = t ?? ((key: string) => key)
-  const [settings, setSettings] = useState<KanbanSettingsShape>({ maxParallelWorkers: 1, defaultModel: '' })
-  const [models, setModels] = useState<Array<{ provider: string; id: string; name?: string }>>([])
+  // Card-local disclosure: collapsed by default, like the built-in plugin cards.
+  const [open, setOpen] = useState(false)
+  const [settings, setSettings] = useState<KanbanSettingsShape>(EMPTY_SETTINGS)
+  const [models, setModels] = useState<ModelOption[]>([])
+  const [presets, setPresets] = useState<PresetOption[]>([])
+  const [efforts, setEfforts] = useState<Record<string, ReasoningOptions>>({})
   const [saved, setSaved] = useState(false)
 
+  const commit = useCallback(async (patch: Partial<KanbanSettingsShape>): Promise<void> => {
+    try {
+      const next = await api.settingsSet(patch)
+      setSettings(next)
+      setSaved(true)
+      window.setTimeout(() => setSaved(false), 1500)
+    } catch {
+      // keep the previous value
+    }
+  }, [])
+
+  // Refs so async callbacks (effort fetch) read the freshest settings/commit.
+  const settingsRef = useRef(settings)
+  settingsRef.current = settings
+  const commitRef = useRef(commit)
+  commitRef.current = commit
+
   useEffect(() => {
     let alive = true
     api.settingsGet()
@@ -159,51 +283,123 @@ export function KanbanSettingsSection({ t }: SettingsSectionProps): JSX.Element
     api.models()
       .then((list) => { if (alive) setModels(list) })
       .catch(() => undefined)
+    api.presets()
+      .then((list) => { if (alive) setPresets(list) })
+      .catch(() => undefined)
     return () => { alive = false }
   }, [])
 
-  const commit = async (patch: Partial<KanbanSettingsShape>): Promise<void> => {
-    try {
-      const next = await api.settingsSet(patch)
-      setSettings(next)
-      setSaved(true)
-      window.setTimeout(() => setSaved(false), 1500)
-    } catch {
-      // keep the previous value
+  /** Reasoning routes already requested (dedupe across mount + model changes). */
+  const effortFetched = useRef<Set<string>>(new Set())
+
+  /**
+   * Fetch the reasoning efforts of one model route (once per route). A failed
+   * fetch is marked `failed` so the stored effort is preserved (see the reset
+   * effect below) instead of being wiped by a transient error.
+   */
+  const loadEfforts = useCallback((provider: string, model: string): void => {
+    const key = `${provider}/${model}`
+    if (effortFetched.current.has(key)) return
+    effortFetched.current.add(key)
+    api.reasoningOptions(provider, model)
+      .then((opts) => setEfforts((prev) => ({ ...prev, [key]: opts })))
+      .catch(() => setEfforts((prev) => ({ ...prev, [key]: { efforts: [], failed: true } })))
+  }, [])
+
+  // Fetch efforts for the models already configured in settings, so the
+  // effort selects show their levels (and validate the stored effort) as soon
+  // as settings load — the fetch previously ran only on model change.
+  useEffect(() => {
+    for (const kind of ['refinement', 'phase'] as const) {
+      const fields = GROUP_FIELDS[kind]
+      const model = settings[fields.model]
+      const provider = settings[fields.provider]
+      if (model !== '' && provider !== '') loadEfforts(provider, model)
     }
-  }
+  }, [settings.refinementModel, settings.refinementProvider, settings.phaseModel, settings.phaseProvider, loadEfforts])
+
+  // When the efforts of the selected model arrive, drop a stored effort the
+  // model no longer offers (e.g. the user switched the model). A failed fetch
+  // (`failed: true`) keeps the stored effort: the model may just be
+  // temporarily unresolvable, and wiping the user's choice would be worse.
+  useEffect(() => {
+    const s = settingsRef.current
+    for (const kind of ['refinement', 'phase'] as const) {
+      const fields = GROUP_FIELDS[kind]
+      const model = s[fields.model]
+      const provider = s[fields.provider]
+      const effort = s[fields.effort]
+      if (effort === '' || model === '' || provider === '') continue
+      const opts = efforts[`${provider}/${model}`]
+      if (opts === undefined || opts.failed === true) continue
+      if (!opts.efforts.some((o) => o.id === effort)) {
+        void commitRef.current({ [fields.effort]: '' } as Partial<KanbanSettingsShape>)
+      }
+    }
+  }, [efforts])
 
   return (
-    <div className="kb-settings">
-      <label className="kb-field kb-field-row">
-        <span>{tr('maxParallelWorkers')}</span>
-        <input
-          className="kb-input kb-input-number"
-          type="number"
-          min={1}
-          step={1}
-          value={settings.maxParallelWorkers}
-          onChange={(e) => {
-            const value = Math.max(1, Math.floor(Number(e.target.value) || 1))
-            setSettings((s) => ({ ...s, maxParallelWorkers: value }))
-            void commit({ maxParallelWorkers: value })
-          }}
-        />
-      </label>
-      <label className="kb-field kb-field-row">
-        <span>{tr('defaultModel')}</span>
-        <select
-          className="kb-input"
-          value={settings.defaultModel}
-          onChange={(e) => { void commit({ defaultModel: e.target.value }) }}
-        >
-          <option value="">—</option>
-          {models.map((m) => (
-            <option key={m.provider + '/' + m.id} value={m.id}>{m.name ?? m.id}</option>
-          ))}
-        </select>
-      </label>
-      {saved && <div className="kb-settings-saved">{tr('saved')}</div>}
-    </div>
+    <li className="kb-settings-card" data-open={open ? '' : undefined}>
+      <button
+        type="button"
+        className="kb-settings-card-head"
+        aria-expanded={open}
+        aria-label={(open ? tr('settingsCollapse') : tr('settingsExpand')) + '：' + tr('settingsTitle')}
+        onClick={() => setOpen(!open)}
+      >
+        <span className="kb-settings-card-headText">
+          <span className="kb-settings-card-title">{tr('settingsTitle')}</span>
+          <span className="kb-settings-card-sub">{tr('settingsDescription')}</span>
+        </span>
+        <span className="kb-settings-card-chevron" data-open={open ? '' : undefined} aria-hidden="true">
+          <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
+            <path d="M3.5 5.25L7 8.75L10.5 5.25" stroke="currentColor" strokeWidth="1.5"
+              strokeLinecap="round" strokeLinejoin="round" />
+          </svg>
+        </span>
+      </button>
+      {open && (
+        <div className="kb-settings-card-body">
+          <div className="kb-settings">
+            <label className="kb-field kb-field-row">
+              <span>{tr('maxParallelWorkers')}</span>
+              <input
+                className="kb-input kb-input-number"
+                type="number"
+                min={1}
+                step={1}
+                value={settings.maxParallelWorkers}
+                onChange={(e) => {
+                  const value = Math.max(1, Math.floor(Number(e.target.value) || 1))
+                  setSettings((s) => ({ ...s, maxParallelWorkers: value }))
+                  void commit({ maxParallelWorkers: value })
+                }}
+              />
+            </label>
+            <SessionDefaultsGroup
+              kind="refinement"
+              settings={settings}
+              models={models}
+              presets={presets}
+              efforts={efforts}
+              tr={tr}
+              onCommit={commit}
+              loadEfforts={loadEfforts}
+            />
+            <SessionDefaultsGroup
+              kind="phase"
+              settings={settings}
+              models={models}
+              presets={presets}
+              efforts={efforts}
+              tr={tr}
+              onCommit={commit}
+              loadEfforts={loadEfforts}
+            />
+            {saved && <div className="kb-settings-saved">{tr('saved')}</div>}
+          </div>
+        </div>
+      )}
+    </li>
   )
 }

package/src/server/models.ts

@@ -18,3 +18,43 @@ export async function listModels(ctx: Context): Promise<ModelOption[]> {
   }
   return out
 }
+
+/** One selectable reasoning effort of a model (display vocabulary for the settings picker). */
+export interface ReasoningEffortOption {
+  id: string
+  name: string
+  description?: string
+}
+
+export interface ReasoningOptions {
+  efforts: ReasoningEffortOption[]
+  defaultEffort?: string
+}
+
+/**
+ * Resolve the adapter-owned reasoning efforts of one exact provider/model
+ * route. On-demand (one model at a time) so the settings picker can offer the
+ * levels the selected model actually supports; failures yield an empty list.
+ */
+export async function reasoningOptions(ctx: Context, provider: string, model: string): Promise<ReasoningOptions> {
+  const llm = ctx.get('llm') as
+    | { resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<{
+      reasoning?: { efforts?: Array<{ id: unknown; name: string; description?: string }>; defaultEffort?: unknown }
+    }> }
+    | undefined
+  if (llm === undefined) return { efforts: [] }
+  try {
+    const info = await llm.resolveModelInfo(provider, model)
+    const efforts = (info.reasoning?.efforts ?? []).map((e) => ({
+      id: String(e.id),
+      name: e.name,
+      ...(e.description !== undefined ? { description: e.description } : {}),
+    }))
+    return {
+      efforts,
+      ...(info.reasoning?.defaultEffort !== undefined ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}),
+    }
+  } catch {
+    return { efforts: [] }
+  }
+}

package/src/server/rpc.ts

@@ -6,10 +6,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from '@deepseek-ai/dsh-host-webserver'
-import type { Lane } from '../shared/card.js'
+import type { KanbanSettingsShape, Lane } from '../shared/card.js'
 import type { KanbanRunner } from './runner.js'
 import type { KanbanSettingsFace } from './settings.js'
-import { listModels } from './models.js'
+import { listModels, reasoningOptions } from './models.js'
 
 const API_PREFIX = '/plugins/@fonlan/dsh-task-kanban/api'
 
@@ -152,16 +152,45 @@ export function registerApiRoutes(
 
   route('settings.get', async () => settings.get())
 
+  /** Every settings field the client may write (per-session-type defaults included). */
+  const SETTING_STRING_FIELDS = [
+    'refinementModel',
+    'refinementProvider',
+    'refinementReasoningEffort',
+    'refinementPreset',
+    'phaseModel',
+    'phaseProvider',
+    'phaseReasoningEffort',
+    'phasePreset',
+  ] as const
+
   route('settings.set', async (p) => {
-    const patch: { maxParallelWorkers?: number; defaultModel?: string } = {}
+    const patch: Partial<KanbanSettingsShape> = {}
     if (typeof p.maxParallelWorkers === 'number') patch.maxParallelWorkers = p.maxParallelWorkers
-    if (typeof p.defaultModel === 'string') patch.defaultModel = p.defaultModel
+    for (const key of SETTING_STRING_FIELDS) {
+      if (typeof p[key] === 'string') patch[key] = p[key]
+    }
     await settings.update(patch)
     return settings.get()
   })
 
   route('models.list', async () => listModels(ctx))
 
+  route('presets.list', async () => {
+    const presets = ctx.get('agentPresets') as
+      | { list(): Promise<Array<{ id: string; name?: string; description?: string }>> }
+      | undefined
+    if (presets === undefined) return []
+    const rows = await presets.list()
+    return rows.map((r) => ({ id: r.id, name: r.name, description: r.description }))
+  })
+
+  route('reasoning.options', async (p) => {
+    const provider = requireString(p.provider, 'provider')
+    const model = requireString(p.model, 'model')
+    return reasoningOptions(ctx, provider, model)
+  })
+
   return () => {
     for (const d of disposers) d()
   }