/**
 * The stdio chat app: the default agent spine ({@link
 * @deepseek-ai/dsh-agent-core}) plus the coupled front-door cluster a terminal
 * chat needs — a console logger, the readline UI (the in-package `stdio-chat`
 * module), JSONL session
 * persistence, and one pre-created agent the UI drives under its `main` label.
 *
 * The cluster is BAKED IN, not left to the leaf: a stdio app always logs to the
 * console (stdout is just the terminal) and always pre-creates one agent the
 * readline UI labels `main`. The leaf supplies the swappable backends (the LLM
 * adapter, the bash executor), optional product tools, the optional `hmr`
 * dev-reload plugin, and this app's {@link Config} (model, prompt, persistence
 * root, welcome banner).
 *
 * `hmr` is deliberately a LEAF entry, not baked in here: it is a Loader-only,
 * subprocess-only dev plugin (its constructor throws without `--expose-internals`
 * + a live `loader`, and the in-process test tier cannot even import it), so a
 * package whose `apply` statically pulled it in could never be unit-tested or
 * carry the per-file coverage gate. Unlike the console logger, a stray `hmr` is
 * not a stdout-purity footgun — so leaving it at the leaf costs no safety, while
 * baking the LOGGER in (the real coupling) keeps stdout-vs-no-stdout a property
 * of the artifact.
 *
 * Counterpart to {@link @deepseek-ai/dsh-acp-agent}, which bakes in the OPPOSITE
 * cluster (no stdout logger, no pre-created agents — the ACP bridge reserves
 * stdout for JSON-RPC and creates agents on demand). Splitting the two front
 * doors into two packages makes each cluster a property of the artifact: there
 * is no logger entry in the ACP leaf to get wrong.
 *
 * Plugin export shape: named `name`/`Config`/`apply`, NO default export — the
 * cordis Loader's `unwrapExports` does `exports.default ?? exports`, so a stray
 * default would collapse the module to the bare `apply` and drop the `Config`
 * namespace (see docs/postmortem/0001). This app carries no `inject`, so a
 * collapsed shape would BOOT rather than crash a smoke — the shape is pinned by
 * the explicit `unwrapExports` assertion in this package's unit suite, and the
 * keyless echo smoke proves the composed tree runs through the real Loader.
 *
 * @module @deepseek-ai/dsh-stdio-agent
 */

import type { Context } from 'cordis'
import { randomUUID } from 'node:crypto'
import ConsoleExporter from '@cordisjs/plugin-logger-console'
import z from 'schemastery'
import { SessionId } from '@deepseek-ai/dsh-session'
import ToolRegistry, { type Config as ToolsConfig } from '@deepseek-ai/dsh-tools'
import * as agentCore from '@deepseek-ai/dsh-agent-core'
import SessionPersistenceJsonl from '@deepseek-ai/dsh-session-persistence-jsonl'
import UserInteractionService from '@deepseek-ai/dsh-user-interaction'
import * as toolAskUser from '@deepseek-ai/dsh-tool-ask-user'
import * as uiStdio from './stdio-chat.ts'

export const name = 'stdio-agent'

/**
 * App config: the swappable per-demo values, each routed to where the app wires
 * it. `model`/`resumeSessionId` configure the pre-created agent (through
 * {@link @deepseek-ai/dsh-agent-core}'s forwarded `agents` list); `persona` is
 * the deployment persona (forwarded to the system-prompt plugin); `toolOrder`
 * is the explicit model-facing tool order (forwarded to the system-prompt plugin);
 * fresh sessions use `process.cwd()` as their workspace cwd; resumed sessions
 * keep their persisted cwd. `persistenceRoot` is the JSONL backend's directory;
 * `welcome` is the UI banner.
 */
export interface Config {
  /** Model name for the pre-created agent (must have a registered adapter). */
  model: string
  /** Deployment persona (the system-prompt plugin's `persona` config). */
  persona?: string
  /** Explicit model-facing tool order (the system-prompt plugin's `toolOrder` config; see dsh-system-prompt). */
  toolOrder?: string[]
  /** Tool-registry config — its presentation `mode` (forwarded through agent-core; see dsh-tools). */
  tools?: ToolsConfig
  /** Directory the JSONL session backend writes under. Defaults to `./.sessions`. */
  persistenceRoot?: string
  /** stdin-chat banner printed once on start. Defaults to `'ready.'`. */
  welcome?: string
  /** Skill registry, local-provider, and model-facing consumer config forwarded to agent-core. */
  skills?: agentCore.SkillConfig
  /**
   * If set, the pre-created agent RESUMES this persisted session id instead of
   * starting fresh. Sourced from an env var in the leaf `cordis.yml`
   * (`resumeSessionId: !!js process.env.RESUME_SESSION_ID`).
   */
  resumeSessionId?: string
}

export const Config: z<Config> = z.object({
  model: z.string().required(),
  persona: z.string(),
  // The array default is forced to undefined: ABSENT means "lexicographic
  // order" (the owning dsh-system-prompt schema does the same), while
  // schemastery's native [] default would read as an invalid configured list.
  toolOrder: z.array(z.string()).default(undefined as unknown as string[]),
  tools: ToolRegistry.Config,
  // TODO(single-default-literal): share these schema defaults and defensive
  // apply() fallbacks through named constants while retaining both boundaries.
  persistenceRoot: z.string().default('./.sessions'),
  welcome: z.string().default('ready.'),
  skills: agentCore.SkillConfigSchema,
  resumeSessionId: z.string(),
})

/**
 * Compose the spine with the stdio front door. Console logging, persistence,
 * and user interaction mount first; the readline UI then waits on the agent
 * registry and subscribes to config-start failures before agent-core can start
 * the configured identity. The ask-user tool waits on the completed spine.
 * The `hmr` dev-reload plugin is a leaf concern (see the module doc), so it is
 * not mounted here.
 */
export function apply(ctx: Context, config: Config): void {
  const resumeSessionId = config.resumeSessionId === '' ? undefined : config.resumeSessionId
  const sessionId = SessionId(resumeSessionId ?? `main-session-${randomUUID()}`)
  ctx.plugin(ConsoleExporter)
  ctx.plugin(SessionPersistenceJsonl, { root: config.persistenceRoot ?? './.sessions' })
  ctx.plugin(UserInteractionService)
  ctx.plugin(uiStdio, {
    welcome: config.welcome ?? 'ready.',
    sessionId,
  })
  ctx.plugin(agentCore, {
    ...config.persona !== undefined ? { persona: config.persona } : {},
    ...config.toolOrder !== undefined ? { toolOrder: config.toolOrder } : {},
    ...config.tools !== undefined ? { tools: config.tools } : {},
    agents: [{
      id: 'main',
      model: config.model,
      cwd: process.cwd(),
      ...resumeSessionId === undefined ? { sessionId } : { resumeSessionId: sessionId },
    }],
    ...config.skills !== undefined ? { skills: config.skills } : {},
  })
  ctx.plugin(toolAskUser)
}