gaunt-sloth 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/tui/slashCommands.d.ts

@@ -19,7 +19,125 @@ export interface SlashCommandContext {
     toolsExpanded: boolean;
     /** Whether the docked debug panel is currently shown (drives `/debug` copy). */
     debugVisible: boolean;
+    /**
+     * Pre-rendered, secret-free summary lines of the resolved config, surfaced read-only by
+     * `/config` (GS2-1). The App builds these once from the resolved config (see
+     * {@link formatConfigSummary}); omitted where no config is loaded (e.g. the fixture agent).
+     */
+    configSummary?: string[];
+    /**
+     * TUI-C19 — the actual config-validation warnings (unknown keys / deprecated names) captured at
+     * load, so `/config` can render the DETAILS the standing "config has problems" advisory line
+     * points at. Empty/omitted ⇒ `/config` shows only the resolved summary (a clean config).
+     */
+    configWarnings?: string[];
+    /**
+     * GS2-7 (B20) / GS2-19 — pre-rendered recent-conversation lines for `/history`. The App builds
+     * these fail-soft from the local history store (see `formatConversationList`); omitted when no
+     * store is available (history never enabled / DB missing), in which case `/history` shows an
+     * "unavailable" notice.
+     */
+    historySummary?: string[];
+    /**
+     * GS2-7 (B20) — pre-rendered analytics lines for `/insights` (see `formatInsightsSummary`),
+     * built fail-soft by the App; omitted when no store is available.
+     */
+    insightsSummary?: string[];
+    /**
+     * GS2-7 (B20) — a fail-soft search provider for `/search <query>`, bound by the App to the local
+     * history store (returns already-formatted result lines). Injected (rather than the command
+     * touching the DB) so the registry stays pure and testable with a stub. Omitted when no store is
+     * available, in which case `/search` reports that history is unavailable.
+     */
+    historySearch?: (query: string) => string[];
+    /**
+     * TUI-C18 — the reasoning text of each committed assistant turn, in transcript order (index 0 =
+     * turn 1). `''` for a turn that produced no thinking layer. Drives `/reasoning`, which reprints a
+     * committed turn's thinking (frozen in `<Static>`, so it can never re-expand in place). The App
+     * builds this from the transcript; omitted (empty) where there are no committed turns yet.
+     */
+    turnReasonings?: string[];
+    /**
+     * GS2-46 — the live transcript (all committed turns, tool calls + results) and the resolved
+     * config, for `/debug-dump`. Kept opaque (`unknown`) so this pure module stays decoupled from
+     * the TUI's `TranscriptItem` type and `GthConfig` — forwarded as-is into the injected
+     * `dumpDebugSession` writer (see {@link DebugDumpInput}). Omitted where no session state is
+     * available (e.g. the fixture agent), in which case `/debug-dump` reports itself unavailable.
+     */
+    transcript?: unknown[];
+    /** GS2-46 — see {@link SlashCommandContext.transcript}. */
+    resolvedConfig?: unknown;
+    /**
+     * GS2-46 — fs-writing implementation for `/debug-dump`: writes an UNSANITIZED archive
+     * (transcript, resolved config, env/version info, the in-memory debugLog ring buffer, and
+     * best-effort git repo state) to `~/.gsloth/debug-dumps/<timestamp>/` and returns its path.
+     * Injected by the App the same way `historySearch` is (GS2-7), so this module stays pure and
+     * testable with a fake — the real writer (`packages/core/src/utils/debugDump.ts`) does the
+     * actual I/O. Omitted ⇒ `/debug-dump` reports itself unavailable (fixture / no session state).
+     */
+    dumpDebugSession?: (input: DebugDumpInput) => {
+        archiveDir: string;
+    };
+}
+/**
+ * GS2-46 — the input `/debug-dump` assembles from context and hands to the injected
+ * `dumpDebugSession` writer. `transcript`/`config` are opaque to this pure module (the real
+ * writer, not this file, interprets them); `modelDisplayName` mirrors the field already on
+ * {@link SlashCommandContext}.
+ */
+export interface DebugDumpInput {
+    transcript: unknown[];
+    config: unknown;
+    modelDisplayName: string;
+    /**
+     * GS2-47 — whether the writer should redact secrets from every artifact. Resolved by
+     * {@link resolveDebugDumpRedact} from the config (`debugDump.redact`, default ON) and the
+     * `--unsafe-no-redact` command flag, then threaded straight through to `writeDebugDump`.
+     */
+    redact: boolean;
 }
+/**
+ * The subset of the resolved config `/config` surfaces. Structurally typed (not the full
+ * `GthConfig`) so this pure module stays decoupled from the config types; the caller passes the
+ * real resolved config, which is a superset.
+ */
+export interface ConfigSummaryInput {
+    modelDisplayName?: string;
+    agent?: {
+        backend?: string;
+    };
+    filesystem?: unknown;
+    streamOutput?: boolean;
+    useColour?: boolean;
+    consoleLevel?: unknown;
+    commands?: Record<string, unknown>;
+}
+/**
+ * Build the compact, read-only `/config` summary (GS2-1): a handful of the most orienting
+ * resolved-config fields, one per line, with a pointer to `gth config print` for the full view.
+ * Pure and secret-free — it only reads non-sensitive scalar fields (never API keys / the live
+ * llm instance). Used by the App to fill {@link SlashCommandContext.configSummary}.
+ */
+export declare function formatConfigSummary(config: ConfigSummaryInput): string[];
+/**
+ * The `/config` notice, from the pre-rendered summary lines (or an unavailable fallback).
+ *
+ * TUI-C19 — when config-validation `warnings` are present (unknown keys / deprecated names), they
+ * are rendered FIRST, as the details the standing "config has problems" advisory line points at,
+ * then a blank spacer, then the resolved summary. A clean config (no warnings) reads exactly as
+ * before. Tone flips to `warn` (yellow) while there are warnings so the block reads as caution.
+ */
+export declare function configNotice(summary: string[] | undefined, warnings?: string[]): SlashCommandNotice;
+/** The `/history` notice (GS2-7): recent recorded sessions, or an "unavailable" fallback. */
+export declare function historyNotice(summary: string[] | undefined): SlashCommandNotice;
+/** The `/insights` notice (GS2-7): local analytics summary, or an "unavailable" fallback. */
+export declare function insightsNotice(summary: string[] | undefined): SlashCommandNotice;
+/**
+ * The `/search` notice (GS2-7). With no query it prints usage; otherwise it runs the injected
+ * fail-soft {@link SlashCommandContext.historySearch} provider and renders its result lines. When
+ * no provider is bound (no store), it reports history as unavailable.
+ */
+export declare function searchNotice(args: string[], search: ((query: string) => string[]) | undefined): SlashCommandNotice;
 /**
  * A structured, noticeable command-feedback block (TUI-C14): a title that states WHAT happened
  * plus body lines explaining HOW it affects the user. The component renders these via
@@ -51,6 +169,26 @@ export interface SlashCommandResult {
     toggleDebug?: boolean;
     /** When true, the component toggles tool-call panels between collapsed and expanded. */
     toggleTools?: boolean;
+    /**
+     * EXT-12 — a requested change to the runner's session-scoped auto-approve flag (shell commands
+     * auto-approved this session), from the `/auto-approve` command: `'on'` / `'off'` set it
+     * explicitly, `'toggle'` flips it. The command itself stays pure — it cannot read the runner's
+     * flag — so the App owns the actual apply + the resulting-state notice (mirroring how `/tools`
+     * / `/debug` defer their state-aware copy to the App).
+     */
+    autoApprove?: 'on' | 'off' | 'toggle';
+    /**
+     * TUI-C18 — a committed turn's thinking to REPRINT into the transcript (the `/reasoning` command).
+     * Committed reasoning is frozen in Ink's `<Static>` and can never re-expand in place, so instead of
+     * mutating the old turn we emit a fresh block that reuses the TUI-C15 `💭`/gutter styling. The App
+     * turns this into a `reasoning` transcript item; the command stays pure (it resolves the target from
+     * `turnReasonings`). Absent when the command instead returns a friendly `notice` (no reasoning /
+     * out-of-range).
+     */
+    reprintReasoning?: {
+        reasoning: string;
+        turnNumber: number;
+    };
     /** When true, the component quits the app (runs `onExit`). */
     exit?: boolean;
 }
@@ -60,6 +198,14 @@ export interface SlashCommand {
     name: string;
     /** One-line description shown by `/help`. */
     description: string;
+    /**
+     * EXT-12 — whether this command may be dispatched WHILE a turn is streaming ("during
+     * inference"). Defaults to false: most commands are idle-only. The read-only / session-toggle
+     * commands (e.g. `/auto-approve`, `/tools`, `/debug`, `/help`, `/model`) set this so the user
+     * can flip auto-approval or inspect state mid-turn without interrupting the run. Commands that
+     * mutate the transcript or thread (`/clear`) or end the session (`/exit`) stay idle-only.
+     */
+    availableDuringRun?: boolean;
     run(ctx: SlashCommandContext, args: string[]): SlashCommandResult;
 }
 /** Parsed shape of a `/...` line. `null` for plain (non-slash) input. */
@@ -73,6 +219,28 @@ export interface ParsedSlashCommand {
  * whitespace-separated tokens are the args.
  */
 export declare function parseSlashCommand(input: string): ParsedSlashCommand | null;
+/**
+ * TUI-C10 — the discovery-menu trigger test. The Ink `<PromptInput>` shows the slash-command menu
+ * while the user is typing a bare command: the raw input is a menu query iff its first character is
+ * `/` and it contains no whitespace yet (once a space is typed the user is entering args, so the
+ * menu closes and normal dispatch takes over). Returns the lower-cased query AFTER the slash (so a
+ * bare `/` yields `''` = "show everything"), or `null` when the input is not a menu trigger.
+ *
+ * Kept pure and next to the registry (like {@link parseSlashCommand}) so the menu's show/hide and
+ * filter logic is unit-testable without React.
+ */
+export declare function slashMenuQuery(input: string): string | null;
+/**
+ * TUI-C10 — filter the registry down to the commands that match a menu query, most-relevant first.
+ * Prefix matches (the name starts with the query) rank above looser substring matches; within each
+ * bucket the registry's own order is preserved (so extension-registered commands — appended to the
+ * array — naturally sort after the built-ins). An empty query returns the whole registry, so a bare
+ * `/` lists every command including any the extensions added (never a hardcoded list).
+ *
+ * Pure: takes the registry the caller already built via {@link createCommandRegistry}, so the menu
+ * automatically reflects extension commands without this layer knowing they exist.
+ */
+export declare function filterSlashCommands(registry: SlashCommand[], query: string): SlashCommand[];
 /**
  * The notice for the tool-detail toggle, given the RESULTING (post-toggle) state. Shared by the
  * `/tools` command and the Ctrl+T key handler so the copy is single-sourced (TUI-C14).
@@ -83,6 +251,50 @@ export declare function toolsToggleNotice(expanded: boolean): SlashCommandNotice
  * command reports exactly the state the component will apply.
  */
 export declare function debugToggleNotice(visible: boolean): SlashCommandNotice;
+/**
+ * The notice for the `/auto-approve` toggle (EXT-12), given the RESULTING (post-apply) state.
+ * Shared so the command reports exactly the state the App applies. ON is rendered 'warn' (yellow)
+ * because it disables the approval gate for the session; OFF is 'info'.
+ */
+export declare function autoApproveNotice(on: boolean): SlashCommandNotice;
+/**
+ * EXT-12 — parse the `/auto-approve` argument: no arg (or `toggle`) flips; `on`/`off` (and the
+ * friendly synonyms `enable`/`disable`, `true`/`false`) set explicitly. Returns `null` for an
+ * unrecognized argument so the command can render a usage hint instead of guessing.
+ */
+export declare function parseAutoApproveArg(args: string[]): 'on' | 'off' | 'toggle' | null;
+/**
+ * TUI-C18 — resolve a `/reasoning` invocation against the committed turns' reasoning (in transcript
+ * order, index 0 = turn 1). Pure, so the whole selection + friendly-notice logic is unit-testable
+ * without React:
+ *
+ * - **no arg** → the most recent turn that actually recorded thinking; if none exists, a friendly
+ *   info notice (nothing to show).
+ * - **`<n>`** → turn `n` (1-based). A non-positive / non-integer / out-of-range `n` → a warn notice;
+ *   a valid turn that recorded no thinking → an info notice. Otherwise a `reprintReasoning` request.
+ *
+ * The App renders a `reprintReasoning` result as a fresh reasoning block (reusing the TUI-C15
+ * styling) and a `notice` result via the shared `CommandNotice`.
+ */
+export declare function resolveReasoning(reasonings: string[], args: string[]): SlashCommandResult;
+/**
+ * GS2-47 — resolve whether the `/debug-dump` archive should be redacted. ON by default; opt out via
+ * the config (`debugDump.redact: false`) OR the `--unsafe-no-redact` command flag. Any uncertainty
+ * (no/non-object config) defaults to redacting — fail safe. `resolvedConfig` is opaque here, so this
+ * reads the flag structurally without depending on the `GthConfig` type.
+ */
+export declare function resolveDebugDumpRedact(resolvedConfig: unknown, args: string[]): boolean;
+/**
+ * The `/debug-dump` success notice (a standard 3-line CommandNotice — DL-1: no command reads as
+ * "does nothing"). GS2-47 flips the default to REDACTED: when redaction ran (the default) the note
+ * is softened ("secrets redacted; review before sharing") and points at the opt-out. When the user
+ * opted OUT (raw archive) it is the loud, impossible-to-miss UNSANITIZED warning. Colour follows
+ * DL-8 / the tone rule in maintenance/ux-guidelines.md: the safe, redacted default is normal
+ * feedback (no `tone` ⇒ info), while the raw opt-out is caution and so `tone: 'warn'` (yellow) —
+ * mirroring how `autoApproveNotice` reserves yellow for the dangerous (gate-off) state. Redaction is
+ * best-effort pattern-based, so even the softened note still says review-before-sharing.
+ */
+export declare function debugDumpNotice(archiveDir: string, redacted: boolean): SlashCommandNotice;
 /**
  * Build the default command registry. Returns a fresh array each call so callers may push
  * extension commands onto it (EXT-5) without sharing mutable module state.
@@ -94,5 +306,12 @@ export declare function formatHelp(registry: SlashCommand[]): SlashCommandNotice
  * Dispatch a parsed command against a registry. Unknown commands return a friendly hint
  * rather than throwing, so the component can render it as a system line and never forward
  * the text to the model.
+ *
+ * EXT-12 — when `options.duringRun` is set (a turn is streaming), commands that are not marked
+ * {@link SlashCommand.availableDuringRun} are refused with a friendly notice rather than run,
+ * so mid-turn input can only reach the safe, non-mutating commands (`/auto-approve`, `/tools`,
+ * `/debug`, …). `/help` is always allowed.
  */
-export declare function dispatchSlashCommand(parsed: ParsedSlashCommand, registry: SlashCommand[], ctx: SlashCommandContext): SlashCommandResult;
+export declare function dispatchSlashCommand(parsed: ParsedSlashCommand, registry: SlashCommand[], ctx: SlashCommandContext, options?: {
+    duringRun?: boolean;
+}): SlashCommandResult;