dsh-code 0.6.1 → 0.8.0

package/src/mentions.ts

@@ -1,12 +1,17 @@
 /**
- * Workspace @mention support: file candidates from a bounded async scan of
- * the session cwd, session candidates from the opt-in `sessionReferenceResolver`
- * service, and submission preparation through its `prepare()` API. Picked
- * session mentions land as canonical `@[label](dsh-session:…)` tokens; on
- * submit the text is parsed back into readable `@label` text plus structured
- * references, snapshots are injected via `agent.inject()` before the readable
- * message wakes the driver (`followup` idle, `steer` running) — exactly the
- * upstream README's wiring.
+ * Workspace @mention support: file and directory candidates from a bounded
+ * async scan of the session cwd, session candidates from the opt-in
+ * `sessionReferenceResolver` service, and submission preparation through its
+ * `prepare()` API. Picked session mentions land as canonical
+ * `@[label](dsh-session:…)` tokens; on submit the text is parsed back into
+ * readable `@label` text plus structured references, snapshots are injected
+ * via `agent.inject()` before the readable message wakes the driver
+ * (`followup` idle, `steer` running) — exactly the upstream README's wiring.
+ *
+ * Harness exposes no workspace-file mention service (only session references
+ * plus a post-hoc produced-file linker), so the file index is the lightweight
+ * bounded scan below, kept deliberately smaller than Codex's streaming
+ * gitignore-aware walker.
  *
  * @module @deepseek-ai/dsh-code/mentions
  */
@@ -57,8 +62,17 @@ export interface PreparedMention {
 const SKIP_DIRS = new Set(['.git', 'node_modules', 'lib', 'dist', 'out', '.omc', 'coverage'])
 const MAX_FILES = 4000
 const MAX_DEPTH = 12
+/** Empty-query default rows: proves the index exists without typing (Codex's
+ * popups show something on a bare sigil too). */
+const EMPTY_QUERY_ROWS = 20
 
-/** Bounded async BFS scan of a workspace; unreadable entries are skipped. */
+/**
+ * Bounded async BFS scan of a workspace; unreadable entries are skipped.
+ * Both files and directories are indexed (directories insert with a trailing
+ * slash), mirroring Codex's `MatchType::{File,Directory}` index. Dotfiles and
+ * the {@link SKIP_DIRS} list are excluded, which is a coarser filter than
+ * Codex's gitignore-aware walker but stays dependency-free and bounded.
+ */
 export async function scanWorkspaceFiles(root: string, signal?: AbortSignal): Promise<readonly FileCandidate[]> {
   const found: FileCandidate[] = []
   const pending: Array<{ absolute: string; relative: string; depth: number }> = [{ absolute: root, relative: '', depth: 0 }]
@@ -78,6 +92,7 @@ export async function scanWorkspaceFiles(root: string, signal?: AbortSignal): Pr
       const relative = current.relative === '' ? entry.name : `${current.relative}/${entry.name}`
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || current.depth + 1 > MAX_DEPTH) continue
+        found.push({ path: relative, kind: 'directory' })
         pending.push({ absolute: join(current.absolute, entry.name), relative, depth: current.depth + 1 })
       } else if (entry.isFile()) {
         found.push({ path: relative, kind: 'file' })
@@ -111,7 +126,7 @@ function scoreFile(path: string, query: string): number {
 
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
-  /** Scanned workspace files, cached across one session. */
+  /** Scanned workspace files and directories, cached across one session. */
   files(): Promise<readonly FileCandidate[]>
   /** Ranked menu candidates for the typed `@` query. */
   candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>
@@ -129,49 +144,64 @@ export interface MentionsApi {
 /**
  * Create the mention API for one agent's workspace. A missing
  * session-reference service degrades to file mentions only (the scan still
- * works); `prepare` then passes text through untouched.
+ * works); `prepare` then passes text through untouched. An undefined agent
+ * (a bare launch before any session exists) also degrades to file-only
+ * mentions, so `@` file completion works before the first message.
+ *
+ * `files` is hoisted into the closure so `candidates` never reaches for
+ * `this` — the runner hands `mentions.candidates` to the input editor as a
+ * detached callback, and a `this`-bound method would throw on every `@` key.
  * @param ctx - context carrying the optional `sessionReferenceResolver`.
  * @param agent - the session owner; excluded from its own candidates.
  * @param cwd - workspace root to scan.
  */
-export function createMentions(ctx: Context, agent: Agent, cwd: string): MentionsApi {
+export function createMentions(ctx: Context, agent: Agent | undefined, cwd: string): MentionsApi {
   const resolver = ctx.get('sessionReferenceResolver')
+  const sessionCapable = agent !== undefined && resolver !== undefined
   let filesPromise: Promise<readonly FileCandidate[]> | undefined
+  const files = (): Promise<readonly FileCandidate[]> => {
+    filesPromise ??= scanWorkspaceFiles(cwd)
+    return filesPromise
+  }
 
   return {
-    files(): Promise<readonly FileCandidate[]> {
-      filesPromise ??= scanWorkspaceFiles(cwd)
-      return filesPromise
-    },
+    files,
     async candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]> {
       const needle = query.trim()
-      const [files, sessions] = await Promise.all([
-        this.files(),
-        resolver === undefined
-          ? Promise.resolve([])
-          : resolver.listCandidates(agent, needle, 10, signal).catch(() => []),
+      const [scanned, sessions] = await Promise.all([
+        files(),
+        sessionCapable && needle !== '' && agent !== undefined
+          ? resolver!.listCandidates(agent, needle, 10, signal).catch(() => [] as readonly SessionReferenceCandidate[])
+          : Promise.resolve([] as readonly SessionReferenceCandidate[]),
       ])
-      const fileRows: MentionCandidate[] = files
-        .filter(candidate => scoreFile(candidate.path, needle) > 0)
-        .sort((left, right) => scoreFile(right.path, needle) - scoreFile(left.path, needle))
-        .slice(0, 20)
+      // A bare `@` lists the first path-sorted entries so the menu is live
+      // before any typing; a non-empty needle ranks by the Codex-shaped score.
+      const fileRows: MentionCandidate[] = (needle === ''
+        ? scanned.slice(0, EMPTY_QUERY_ROWS)
+        : scanned
+          .filter(candidate => scoreFile(candidate.path, needle) > 0)
+          .sort((left, right) => scoreFile(right.path, needle) - scoreFile(left.path, needle))
+          .slice(0, 20))
         .map(candidate => ({
           label: candidate.path,
           description: candidate.kind === 'directory' ? 'Folder' : 'File',
           kind: candidate.kind,
         }))
+      // Sessions join only with a typed needle and always AFTER the file
+      // rows: `@` is a file mention first (Codex's semantics), and session
+      // references are the secondary vocabulary.
       const sessionRows: MentionCandidate[] = sessions.map(candidate => ({
         label: formatSessionReferenceMention(candidate),
         description: `Session · ${candidate.cwd ?? '(no cwd)'}`,
         kind: 'session',
       }))
-      return [...sessionRows, ...fileRows]
+      return [...fileRows, ...sessionRows]
     },
     parse(text: string): ParsedSessionReferenceText {
       return parseSessionReferenceText(text)
     },
     async prepare(parsed: ParsedSessionReferenceText, signal?: AbortSignal): Promise<PreparedMention> {
-      if (parsed.references.length === 0 || resolver === undefined) {
+      if (parsed.references.length === 0 || resolver === undefined || agent === undefined) {
         return { text: parsed.text, references: parsed.references }
       }
       const prepared = await resolver.prepare(

package/src/models.ts

@@ -1,66 +1,200 @@
-/**
- * Model directory for the `/model` panel: the in-process equivalent of the
- * web host's model catalog (`buildModelCatalog`), reading the advisory
- * `ctx.llm` registry directly. Catalog membership is advisory — a route
- * serving a model it stopped advertising stays usable — so selection never
- * fails on catalog absence alone.
- *
- * @module @deepseek-ai/dsh-tui/models
- */
-
-import type { Context } from '@deepseek-ai/cordis'
-import type { LlmModelInfo } from '@deepseek-ai/dsh-llm'
-
-/** One selectable row in the `/model` panel. */
-export interface ModelRow {
-  /** Registered provider route. */
-  provider: string
-  /** Display name of the provider route. */
-  providerName: string
-  /** Provider-owned model id. */
-  model: string
-  /** Human-readable model name. */
-  modelName: string
-}
-
-/** The resolved directory: rows plus per-provider discovery failures. */
-export interface ModelDirectory {
-  /** Advisory rows, provider-major in registry order. */
-  rows: readonly ModelRow[]
-  /** Provider ids whose model listing failed; those providers contribute no rows. */
-  failures: readonly string[]
-}
-
-/**
- * Load the selectable model directory from the live `ctx.llm` registry.
- * Providers are listed synchronously; each provider's models are discovered
- * with a bounded parallel fan-out whose failures degrade to that provider
- * contributing no rows (mirrors the web catalog's per-provider failures).
- * @param ctx - context carrying the `llm` service.
- * @returns the resolved directory; empty rows when `llm` is unavailable.
- */
-export async function loadModelDirectory(ctx: Context): Promise<ModelDirectory> {
-  const llm = ctx.get('llm')
-  if (llm === undefined) return { rows: [], failures: [] }
-  const providers = llm.listProviders()
-  const listed = await Promise.all(providers.map(async (provider) => {
-    try {
-      const models: readonly LlmModelInfo[] = await llm.listModels(provider.id)
-      return {
-        provider: provider.id,
-        providerName: provider.name,
-        models: models.map(model => ({
-          provider: provider.id,
-          providerName: provider.name,
-          model: model.id,
-          modelName: model.name,
-        })),
-      }
-    } catch {
-      return { provider: provider.id, providerName: provider.name, models: [] as ModelRow[], failed: true }
-    }
-  }))
-  const rows = listed.flatMap(entry => entry.models)
-  const failures = listed.filter(entry => 'failed' in entry && entry.failed === true).map(entry => entry.provider)
-  return { rows, failures }
-}
+/**
+ * Model directory for the `/model` panel: the in-process equivalent of the
+ * web host's model catalog (`buildModelCatalog`), reading the advisory
+ * `ctx.llm` registry directly. Catalog membership is advisory — a route
+ * serving a model it stopped advertising stays usable — so selection never
+ * fails on catalog absence alone.
+ *
+ * @module @deepseek-ai/dsh-tui/models
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { ModelSelection } from '@deepseek-ai/dsh-agent'
+import {
+  ReasoningEffortId,
+  type LlmModelInfo,
+  type LlmModelReasoningInfo,
+  type LlmResolvedModelInfo,
+} from '@deepseek-ai/dsh-llm'
+
+/** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
+export interface ModelReasoningEffort {
+  /** Opaque value accepted by the model's `GenerateOptions.reasoningEffort`. */
+  id: string
+  /** Human-readable effort name for selectors. */
+  name: string
+  /** Optional user-facing distinction from otherwise similar efforts. */
+  description?: string
+}
+
+/** Selectable reasoning efforts for one model (mirrors `LlmModelReasoningInfo`). */
+export interface ModelReasoning {
+  /** Supported efforts in adapter-preferred display order. */
+  efforts: readonly ModelReasoningEffort[]
+  /** Adapter-configured default materialized when callers omit an effort. */
+  defaultEffort?: string
+}
+
+/** One selectable row in the `/model` panel. */
+export interface ModelRow {
+  /** Registered provider route. */
+  provider: string
+  /** Display name of the provider route. */
+  providerName: string
+  /** Provider-owned model id. */
+  model: string
+  /** Human-readable model name. */
+  modelName: string
+  /** Adapter-owned selectable reasoning levels when the model exposes any. */
+  reasoning?: ModelReasoning
+}
+
+/** The resolved directory: rows plus per-provider discovery failures. */
+export interface ModelDirectory {
+  /** Advisory rows, provider-major in registry order. */
+  rows: readonly ModelRow[]
+  /** Provider ids whose model listing failed; those providers contribute no rows. */
+  failures: readonly string[]
+  /**
+   * `provider/model` labels whose per-model capability lookup failed. Those
+   * rows still appear (advisory degrade, mirroring the web catalog), but
+   * without an effort picker — a picker caller must not misread the absence
+   * as "this model exposes no reasoning" (e.g. deepseek-v4-flash always
+   * advertises off/high/max unless thinking is disabled). Optional for
+   * callers that shape a directory by hand; {@link loadModelDirectory}
+   * always populates it (empty when nothing failed).
+   */
+  reasoningFailures?: readonly string[]
+}
+
+/** Map an adapter's reasoning capability onto the panel's plain-id shape. */
+export function mapReasoning(reasoning: LlmModelReasoningInfo): ModelReasoning {
+  return {
+    efforts: reasoning.efforts.map(effort => ({
+      id: effort.id,
+      name: effort.name,
+      ...effort.description === undefined ? {} : { description: effort.description },
+    })),
+    ...reasoning.defaultEffort === undefined ? {} : { defaultEffort: reasoning.defaultEffort },
+  }
+}
+
+/**
+ * Resolve the effective model selection for one live session, in the
+ * documented precedence: the in-process explicit pick, then the session's
+ * last `request/header` config, then the deployment default.
+ * @param picked - the explicit selection made in this process, when any.
+ * @param logged - the last logged request header config, when any.
+ * @param defaults - the deployment default selection.
+ * @returns the effective selection, carrying a reasoning effort when one is in force.
+ */
+export function resolveEffectiveSelection(
+  picked: ModelSelection | undefined,
+  logged: { provider: string; model: string; reasoningEffort?: string } | undefined,
+  defaults: ModelSelection,
+): ModelSelection {
+  if (picked !== undefined) return picked
+  if (logged !== undefined) {
+    return {
+      provider: logged.provider,
+      model: logged.model,
+      ...logged.reasoningEffort === undefined
+        ? {}
+        : { reasoningEffort: ReasoningEffortId(logged.reasoningEffort) },
+    }
+  }
+  return defaults
+}
+
+/**
+ * Build the selection one `/model` pick applies, rejecting an effort the
+ * row does not advertise. The row is the picker's source of truth, so a
+ * stale directory cannot smuggle an unsupported effort into the next step
+ * (the request pipeline would reject it before network I/O regardless). The
+ * empty string is the picker's "provider default" sentinel — an explicit
+ * choice to leave the effort to the model's own default, exactly like an
+ * absent effort.
+ * @param row - the picked model row.
+ * @param effortId - the chosen advertised effort, '' or undefined for the model default.
+ * @returns the selection the runner records for the next assembled step.
+ */
+export function buildModelSelection(row: ModelRow, effortId?: string): ModelSelection {
+  const selected = effortId === undefined || effortId === '' ? undefined : effortId
+  if (selected !== undefined
+    && (row.reasoning === undefined || !row.reasoning.efforts.some(effort => effort.id === selected))) {
+    throw new Error(`model ${row.provider}/${row.model} does not support reasoning effort "${selected}"`)
+  }
+  return {
+    provider: row.provider,
+    model: row.model,
+    ...selected === undefined ? {} : { reasoningEffort: ReasoningEffortId(selected) },
+  }
+}
+
+/** Display label for one applied selection: `provider/model` or `provider/model@effort`. */
+export function modelSelectionLabel(selection: ModelSelection): string {
+  return selection.reasoningEffort === undefined
+    ? `${selection.provider}/${selection.model}`
+    : `${selection.provider}/${selection.model}@${selection.reasoningEffort}`
+}
+
+/**
+ * Load the selectable model directory from the live `ctx.llm` registry.
+ * Providers are listed synchronously; each provider's models are discovered
+ * with a bounded parallel fan-out whose failures degrade to that provider
+ * contributing no rows (mirrors the web catalog's per-provider failures).
+ * Each row's reasoning levels are resolved per exact model like the web
+ * catalog (`buildModelCatalog`); a single model's capability lookup failure
+ * degrades to that row having no effort picker rather than hiding the model,
+ * and the failure rides `reasoningFailures` so the caller can tell "no
+ * advertised reasoning" from "capability lookup failed".
+ * @param ctx - context carrying the `llm` service.
+ * @returns the resolved directory; empty rows when `llm` is unavailable.
+ */
+export async function loadModelDirectory(ctx: Context): Promise<ModelDirectory> {
+  const llm = ctx.get('llm')
+  if (llm === undefined) return { rows: [], failures: [], reasoningFailures: [] }
+  // Call resolveModelInfo AS A METHOD (llm.resolveModelInfo(...)): destructured
+  // off the service it loses `this` — this.registration() then throws on the
+  // first provider, the catch swallows it, and every row lands in
+  // reasoningFailures ("capability lookup failed") even though the adapter
+  // itself never fails.
+  const llmResolve = llm as { resolveModelInfo?: (provider: string, model: string) => Promise<LlmResolvedModelInfo> }
+  const providers = llm.listProviders()
+  const listed = await Promise.all(providers.map(async (provider) => {
+    try {
+      const models: readonly LlmModelInfo[] = await llm.listModels(provider.id)
+      const reasoningFailures: string[] = []
+      const rows = await Promise.all(models.map(async (model): Promise<ModelRow> => {
+        const row: ModelRow = {
+          provider: provider.id,
+          providerName: provider.name,
+          model: model.id,
+          modelName: model.name,
+        }
+        if (llmResolve.resolveModelInfo === undefined) return row
+        try {
+          const resolved = await llmResolve.resolveModelInfo(provider.id, model.id)
+          return resolved.reasoning === undefined
+            ? row
+            : { ...row, reasoning: mapReasoning(resolved.reasoning) }
+        } catch {
+          reasoningFailures.push(`${provider.id}/${model.id}`)
+          return row
+        }
+      }))
+      return {
+        provider: provider.id,
+        providerName: provider.name,
+        models: rows,
+        reasoningFailures,
+      }
+    } catch {
+      return { provider: provider.id, providerName: provider.name, models: [] as ModelRow[], failed: true }
+    }
+  }))
+  const rows = listed.flatMap(entry => entry.models)
+  const failures = listed.filter(entry => 'failed' in entry && entry.failed === true).map(entry => entry.provider)
+  const reasoningFailures = listed.flatMap(entry => 'failed' in entry ? [] : entry.reasoningFailures)
+  return { rows, failures, reasoningFailures }
+}

package/src/permissions.ts

@@ -0,0 +1,85 @@
+/** Permission-preset policy for pending and active TUI sessions. */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+
+/** One selectable permission preset row for the /permission panel. */
+export interface PermissionRow {
+  readonly id: string
+  readonly description?: string
+}
+
+/** Structural boundary over Harness permission presets; values stay service-owned. */
+export interface PermissionPresetsService {
+  readonly names: readonly string[]
+  readonly defaultPreset: string
+  resolve(name: string): unknown
+  current(events: readonly SessionEvent[]): string
+  set(session: Session, preset: string): void
+  /** Client presentation metadata for one preset; may reject unknown names. */
+  optionOf?(name: string): { name: string; description?: string } | undefined
+}
+
+/** Read the optional Harness service without importing its runtime package. */
+export function permissionPresetsFrom(ctx: Context): PermissionPresetsService | undefined {
+  return (ctx as unknown as { get(name: string): unknown }).get('permissionPresets') as PermissionPresetsService | undefined
+}
+
+/** Effective label for either an active session or the not-yet-created first one. */
+export function effectivePermission(
+  service: PermissionPresetsService,
+  session: Session | undefined,
+  pending: string | undefined,
+): string {
+  return session === undefined ? pending ?? service.defaultPreset : service.current(session.events)
+}
+
+/** Validate a preset and write it only when a durable session already exists. */
+export function selectPermission(
+  service: PermissionPresetsService,
+  session: Session | undefined,
+  preset: string,
+): string {
+  service.resolve(preset)
+  if (session !== undefined) service.set(session, preset)
+  return preset
+}
+
+/** Cycle table order from the active, pending, or configured-default value. */
+export function cyclePermission(
+  service: PermissionPresetsService,
+  session: Session | undefined,
+  pending: string | undefined,
+): string {
+  if (service.names.length === 0) return ''
+  const at = service.names.indexOf(effectivePermission(service, session, pending))
+  const next = service.names[(at + 1) % service.names.length] ?? ''
+  return next === '' ? '' : selectPermission(service, session, next)
+}
+
+/** Materialize a pre-session choice after Harness creates the first session. */
+export function applyPendingPermission(
+  service: PermissionPresetsService,
+  session: Session,
+  pending: string | undefined,
+): void {
+  if (pending !== undefined && effectivePermission(service, session, undefined) !== pending) {
+    selectPermission(service, session, pending)
+  }
+}
+
+/**
+ * List every switchable preset for the /permission panel, table order kept.
+ * Description lookup failures degrade to an undocumented row, never a failed
+ * panel load — `optionOf` rejects names its table no longer knows.
+ */
+export function listPermissionRows(service: PermissionPresetsService): readonly PermissionRow[] {
+  return service.names.map((id) => {
+    if (service.optionOf === undefined) return { id }
+    try {
+      return { id, description: service.optionOf(id)?.description }
+    } catch {
+      return { id }
+    }
+  })
+}

package/src/presets.ts

@@ -45,6 +45,18 @@ export function resolvePreset(session: Pick<Session, 'header' | 'events'>): stri
   return session.header.agentPreset ?? 'standard'
 }
 
+/** Resolve a pre-session choice, or recompose an active blank Agent. */
+export async function selectPreset(
+  service: AgentPresetsService,
+  agent: Agent | undefined,
+  presetId: string,
+): Promise<PresetRow> {
+  if (agent !== undefined) return switchPreset(service, agent, presetId)
+  const preset = await service.resolve(presetId)
+  if (preset.broken !== undefined) throw new Error(preset.broken)
+  return preset
+}
+
 /** Recompose atomically from the caller's perspective, logging only success. */
 export async function switchPreset(
   service: AgentPresetsService,