indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/console/slash/commands/shared.d.ts

@@ -1,72 +0,0 @@
-/**
- * Shared slash-command helpers — the small, pure toolkit every command group is
- * written against.
- *
- * The console's slash catalog is split into topic groups (transcript control,
- * the workbench pickers, the integration bridges). Each group is its own module
- * exporting a `SlashCommand[]`; this file holds the handful of helpers they all
- * lean on so the groups stay free of duplicated wiring and the family
- * sub-command dispatch lives in exactly one place.
- *
- * Two stances every group keeps:
- *   1. **Handlers are thin.** A `run(ctx)` never reaches into React, the
- *      filesystem, or a provider SDK; every effect goes through the injected
- *      {@link SlashContext}. The handler decides *which* effect to raise.
- *   2. **Families are tables, not ladders.** A command with sub-verbs (e.g.
- *      `/memory note|show|forget`) is built from a {@link SubCommand} table via
- *      {@link familyRunner}, never a hand-written `if`-chain.
- */
-import type { SlashContext, SlashOutcome, StatusMessage } from "../../contract";
-/**
- * The family labels the catalog groups commands under for `/help` and
- * completion. Named constants (not bare strings scattered across rows) so the
- * grouping a command declares and the grouping the help view renders cannot
- * drift apart.
- */
-export declare const FAMILY: {
-    readonly composio: "composio";
-    readonly memory: "memory";
-    readonly scopedModels: "models-for";
-    readonly theme: "theme";
-};
-/** The settled "command ran, nothing more to do" outcome. */
-export declare const HANDLED: SlashOutcome;
-/** Mint an info-tone status toast. */
-export declare function info(text: string): StatusMessage;
-/** Mint a warning-tone status toast (used for usage hints on bad args). */
-export declare function warn(text: string): StatusMessage;
-/**
- * Split a family command's argument string into a leading sub-command verb and
- * the remainder, both trimmed. An empty argument string yields an empty verb so
- * a family command can show its own usage when invoked bare.
- *
- * @param args the raw trailing argument string from {@link SlashContext.args}
- */
-export declare function splitVerb(args: string): {
-    verb: string;
-    rest: string;
-};
-/**
- * One sub-command of a command family — its verb, a one-line description for the
- * usage list, and the thin action it runs through the {@link SlashContext}.
- */
-export interface SubCommand {
-    /** The sub-command verb, lower-cased (e.g. `add`, `list`, `clear`). */
-    readonly verb: string;
-    /** One-line description rendered in the family's usage toast. */
-    readonly describe: string;
-    /** Run the sub-command; `rest` is the argument tail after the verb. */
-    run(ctx: SlashContext, rest: string): SlashOutcome;
-}
-/**
- * Build a family command's `run` from a sub-command table.
- *
- * The family handler is a single thin function whose branch structure is
- * *generated* from the table: it splits the verb, looks it up, and runs the
- * matching action — falling back to a usage toast (assembled from the table's
- * descriptions) when the verb is missing or unknown.
- *
- * @param family the family label, used in the usage header
- * @param subs   the sub-command table for this family
- */
-export declare function familyRunner(family: string, subs: readonly SubCommand[]): (ctx: SlashContext) => SlashOutcome;

package/dist/types/console/slash/commands/transcript.d.ts

@@ -1,24 +0,0 @@
-/**
- * Transcript & session-control slash commands.
- *
- * The first topic group of the console's slash catalog: the verbs that reset,
- * rename, branch, inspect, or leave the live session view. Every row is a thin
- * {@link SlashCommand} whose `run` drives the injected {@link SlashContext} — a
- * reducer event, a conductor call, a modal, or an exit request — and settles to
- * {@link HANDLED}. Nothing here reaches into React, the filesystem, or a
- * provider SDK directly; backend work flows through the {@link SessionConductor}.
- *
- * The rename, stats, condense, and reload verbs are backed by real conductor
- * surface ({@link SessionConductor.setSessionName}, {@link SessionConductor.stats},
- * {@link SessionConductor.condense}). Where the conductor cannot accept a richer
- * input (the condense path is parameterless on this build), the closest real
- * action is taken and the status line explains precisely what was applied.
- */
-import type { SlashCommand } from "../../contract";
-/**
- * The transcript / session-control group, in listing order.
- *
- * Appended into the slash registry by the catalog integrator; this module owns
- * only the rows, never the wiring.
- */
-export declare const transcriptCommands: SlashCommand[];

package/dist/types/console/slash/commands/transcript.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Focused tests for the transcript / session-control slash group.
- *
- * Each command is exercised against a scripted {@link SlashContext} fake that
- * records every effect it raises (reducer events, status toasts, modal opens,
- * conductor calls, exit requests). The assertions check that each verb raises
- * exactly the effect its contract promises and settles to `handled` without
- * throwing.
- */
-export {};

package/dist/types/console/slash/commands/workbench.d.ts

@@ -1,21 +0,0 @@
-/**
- * Workbench slash commands — the pickers, display blocks, and help surfaces.
- *
- * This group covers the overlays a user reaches for to inspect or retune the
- * session: the model pickers, the per-scope routing editor, the colour-scheme
- * switch, the settings list, the command palette (`/help`), the keyboard map
- * (`/keys`), the project changelog (`/whats-new`), and a diagnostics dump
- * (`/debug`). The picker handlers stay thin — they raise an overlay through
- * {@link SlashContext.openModal} or flip a reducer flag — while the help,
- * keys, whats-new, and debug handlers do real work: they read the live slash
- * catalog, the grounded keymap, a `CHANGELOG.md` on disk, and the conductor's
- * session statistics, then surface the result as a display block or a written
- * file rather than a dead placeholder.
- */
-import type { SlashCommand } from "../../contract";
-/**
- * The workbench command rows, in listing order. Pickers and help surfaces open
- * an overlay; the changelog drops a display block; debug flips a toggle and
- * reports it.
- */
-export declare const workbenchCommands: SlashCommand[];

package/dist/types/console/slash/commands/workbench.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Workbench command group — focused handler tests.
- *
- * Each command is driven against a scripted {@link SlashContext} fake that
- * records every injected action, so a handler's effect is asserted by
- * inspecting the recorded overlays / dispatches / statuses / blocks rather than
- * a rendered surface. The group stays thin: every handler resolves to a settled
- * outcome and raises exactly the effects its row promises.
- */
-export {};

package/dist/types/console/slash/index.d.ts

@@ -1,34 +0,0 @@
-/**
- * Slash subsystem — public barrel.
- *
- * The console's data-driven slash layer, in three pure pieces:
- *
- *   - **The catalog** — {@link SLASH_COMMANDS}, the single ordered list of
- *     {@link SlashCommand} rows (core commands plus the `composio` / `memory` /
- *     `scoped-models` / `theme` families). There is no command `if`-ladder; a new
- *     command is a new row.
- *   - **The registry** — {@link buildRegistry} folds the catalog into the frozen
- *     {@link SlashRegistry} shape (commands + a name/alias index), and the derived
- *     lookups ({@link matchPrefix}, {@link findCommand}, {@link commandsInFamily},
- *     {@link listFamilies}) power resolution, completion, and grouped listing.
- *   - **Resolution** — {@link resolveSlash} parses a typed composer line and
- *     resolves it against a registry to a discriminated {@link SlashResolution}.
- *
- * {@link DEFAULT_SLASH_REGISTRY} is the catalog pre-folded into a registry, the
- * value the console mounts with. The effectful dispatcher (which calls a matched
- * command's `run`) lives outside this barrel; everything exported here is pure.
- */
-export { SLASH_COMMANDS, FAMILY } from "./builtins";
-export { buildRegistry, tokensOf, findCommand, matchPrefix, listFamilies, commandsInFamily, } from "./registry";
-export { SLASH_PREFIX, looksLikeSlash, parseSlash, resolveSlash, type SlashLine, type SlashResolution, } from "./resolve";
-import type { SlashRegistry } from "../contract";
-/**
- * The built-in catalog pre-folded into a resolved {@link SlashRegistry}.
- *
- * The default the console mounts with: the catalog indexed by every canonical
- * name and alias, ready for {@link resolveSlash} and the completion matcher. A
- * caller that needs to splice in prompt templates, plugin commands, or
- * `/skill:*` entries builds its own registry from a concatenated list via
- * {@link buildRegistry} rather than mutating this one.
- */
-export declare const DEFAULT_SLASH_REGISTRY: SlashRegistry;

package/dist/types/console/slash/registry.d.ts

@@ -1,90 +0,0 @@
-/**
- * Slash registry assembly — fold a command list into the resolved registry.
- *
- * The slash subsystem keeps exactly one hand-maintained list of commands (the
- * {@link SLASH_COMMANDS} array in `builtins.ts`); everything a consumer needs to
- * resolve, complete, or list a command is *derived* from that array here. This
- * module is the bridge between the flat data and the {@link SlashRegistry} shape
- * the contract froze:
- *
- *   - {@link buildRegistry} indexes the list by canonical name *and* by every
- *     alias, so {@link import("./resolve").resolveSlash} is an O(1) map lookup
- *     rather than a scan. It also guards the one invariant a flat array cannot:
- *     two rows must not claim the same token (a duplicate name or alias is a
- *     programming error, surfaced loudly at assembly time, not silently shadowed).
- *   - {@link matchPrefix} powers the completion window: given the partial token
- *     the user has typed, it returns the rows whose name or alias starts with it,
- *     in registry order.
- *   - {@link commandsInFamily} / {@link listFamilies} project the `family` field
- *     for grouped listing (the `/help` overlay, the completion grouping).
- *
- * No effects, no React, no conductor — the registry is a value, and these are
- * pure derivations over it. The dispatcher consumes the registry; it is not
- * built here.
- */
-import type { SlashCommand, SlashRegistry } from "../contract";
-/**
- * Every token a command answers to: its canonical name plus any aliases.
- *
- * The single place name/alias enumeration happens, so the index builder and the
- * prefix matcher agree on what counts as "a token for this command".
- *
- * @param command the command to enumerate tokens for
- */
-export declare function tokensOf(command: SlashCommand): string[];
-/**
- * Fold an ordered command list into a resolved {@link SlashRegistry}.
- *
- * Preserves the input order in {@link SlashRegistry.commands} (it is the listing
- * order the completion window and `/help` render in) and derives the
- * {@link SlashRegistry.index} by mapping every token — canonical and alias — to
- * its owning command. Tokens are lower-cased on the way in so resolution can be
- * case-insensitive without the resolver re-normalising.
- *
- * Throws when two rows claim the same token: a flat array cannot express
- * "these names are disjoint", so the invariant is enforced here, at the one
- * point the table is assembled, instead of letting a later row silently shadow
- * an earlier one.
- *
- * @param commands the ordered command list (the single source of truth)
- */
-export declare function buildRegistry(commands: readonly SlashCommand[]): SlashRegistry;
-/**
- * Resolve a single token (canonical or alias) to its command, or `undefined`.
- *
- * A thin, case-insensitive read of {@link SlashRegistry.index} so call sites do
- * not re-implement the lower-casing the registry index expects.
- *
- * @param registry the registry to read
- * @param token    a canonical name or alias, with or without a leading slash
- */
-export declare function findCommand(registry: SlashRegistry, token: string): SlashCommand | undefined;
-/**
- * The commands whose name or alias begins with a partial token, in registry
- * order — the candidate set the completion window renders.
- *
- * Matching is case-insensitive and prefix-based against *every* token a command
- * answers to, but each command appears at most once even when several of its
- * tokens match. An empty partial returns the whole list (the bare-`/` case where
- * the user has opened the completion window but typed nothing yet).
- *
- * @param registry the registry to search
- * @param partial  the partial command token (without a leading slash)
- */
-export declare function matchPrefix(registry: SlashRegistry, partial: string): SlashCommand[];
-/**
- * The distinct family labels present in the registry, in first-seen order.
- *
- * Commands without a `family` are omitted; the result drives the grouped
- * headings in `/help` and the completion window.
- *
- * @param registry the registry to scan
- */
-export declare function listFamilies(registry: SlashRegistry): string[];
-/**
- * The commands belonging to a family, in registry order.
- *
- * @param registry the registry to filter
- * @param family   the family label to select
- */
-export declare function commandsInFamily(registry: SlashRegistry, family: string): SlashCommand[];

package/dist/types/console/slash/resolve.d.ts

@@ -1,109 +0,0 @@
-/**
- * Slash line resolution — parse a typed line, then match it against the registry.
- *
- * This module is the pure front half of the slash subsystem: it takes the raw
- * string a user typed into the composer and decides three things, in order:
- *
- *   1. **Is this a slash line at all?** A line is a slash invocation only when its
- *      first non-blank character is `/` and what follows is a command-shaped
- *      token (so a bare `/` or a `/path/to/file` literal is *not* hijacked as a
- *      command). {@link parseSlash} reports this without consulting the registry.
- *   2. **Which command does the token resolve to?** {@link resolveSlash} folds a
- *      {@link SlashRegistry} in: it splits the line into a name and a trailing
- *      argument string, then resolves the name (and its aliases) through the
- *      registry's index. Resolution is case-insensitive on the command token.
- *   3. **What should the dispatcher do?** The result is a discriminated
- *      {@link SlashResolution}: `not-slash` (treat as a normal prompt / bash
- *      escape), `match` (run this command with these args), or `miss` (it looked
- *      like a command but no row owns the token — fall through to templates,
- *      plugin commands, or a literal prompt).
- *
- * Nothing here touches React, the conductor, or I/O — the whole module is a pair
- * of pure functions over a string and a registry, which is exactly why the slash
- * parsing/matching logic lives here rather than inside a `useInput` handler. The
- * effectful half (actually calling a command's `run`) is the dispatcher's job.
- */
-import type { SlashCommand, SlashRegistry } from "../contract";
-/**
- * The leading character that marks a line as a slash invocation.
- *
- * A single constant so the prefix is defined in exactly one place and the tests
- * assert against the same literal the parser reads.
- */
-export declare const SLASH_PREFIX: "/";
-/**
- * The lexical split of a slash line into its command token and argument tail.
- *
- * Produced by {@link parseSlash} before the registry is consulted, so the two
- * concerns — "did the user type a command-shaped line" and "does a command own
- * that token" — stay separable. `name` is the bare token with no leading slash
- * and folded to lower case for case-insensitive matching; `args` is everything
- * after the first run of whitespace, with the single separating space removed
- * but interior spacing preserved.
- */
-export interface SlashLine {
-    /** The command token, lower-cased, without the leading slash. */
-    readonly name: string;
-    /** The trailing argument string (may be empty), interior spacing preserved. */
-    readonly args: string;
-}
-/**
- * Whether a typed line is shaped like a slash command at all.
- *
- * A line qualifies only when, after trimming leading blanks, it begins with the
- * {@link SLASH_PREFIX} *and* what follows up to the first whitespace is a clean
- * {@link COMMAND_TOKEN}. This deliberately rejects a lone `/`, a `//comment`, and
- * a `/usr/local/bin` style path (whose embedded slash breaks the token shape) so
- * those reach the prompt untouched.
- *
- * @param input the raw composer line
- */
-export declare function looksLikeSlash(input: string): boolean;
-/**
- * Split a slash line into its {@link SlashLine} token/argument pair, or
- * `undefined` when the line is not shaped like a command.
- *
- * The token runs from just after the slash up to the first whitespace (or
- * end-of-line); the argument tail is whatever follows that whitespace, trimmed
- * only at its outer edges. The token is lower-cased so resolution can be
- * case-insensitive without the caller pre-normalising.
- *
- * @param input the raw composer line
- */
-export declare function parseSlash(input: string): SlashLine | undefined;
-/**
- * The outcome of resolving a typed line against a {@link SlashRegistry}.
- *
- *   - `not-slash` — the line is not a command invocation; the dispatcher should
- *     hand it on as a normal prompt (or a `!`/`!!` bash escape).
- *   - `match`     — the token resolved to `command`; run it with `args` (the raw
- *     trailing string) via a {@link import("../contract").SlashContext}.
- *   - `miss`      — the line *was* command-shaped but no row owns the token; the
- *     dispatcher falls through to templates / plugin commands / a literal prompt.
- *     The offending `name` is reported so a caller can surface "unknown command".
- */
-export type SlashResolution = {
-    readonly kind: "not-slash";
-} | {
-    readonly kind: "match";
-    readonly command: SlashCommand;
-    readonly args: string;
-} | {
-    readonly kind: "miss";
-    readonly name: string;
-};
-/**
- * Resolve a raw composer line against the registry to a {@link SlashResolution}.
- *
- * Parses the line ({@link parseSlash}); a non-command line resolves to
- * `not-slash`. A command-shaped line's token is looked up in the registry index
- * (which already carries both canonical names and aliases), yielding `match`
- * with the owning command and the raw argument string, or `miss` when no row
- * claims the token.
- *
- * This is the single entry point a dispatcher calls; it performs no effects.
- *
- * @param input    the raw composer line
- * @param registry the registry to resolve against
- */
-export declare function resolveSlash(input: string, registry: SlashRegistry): SlashResolution;

package/dist/types/console/slash/slash.test.d.ts

@@ -1,18 +0,0 @@
-/**
- * Slash subsystem — pure-module tests.
- *
- * Exercises the three pure pieces end-to-end without React, a real conductor, or
- * I/O: a scripted {@link SlashContext} fake records every injected action a
- * handler calls, so a command's effect is asserted by inspecting the recorded
- * calls rather than a rendered surface.
- *
- *   1. Line parsing — `parseSlash` / `looksLikeSlash` distinguish commands from
- *      bare slashes, paths, and plain prompts, and split off the argument tail.
- *   2. Registry assembly — `buildRegistry` indexes names + aliases, rejects
- *      duplicate tokens, and the derived lookups (`matchPrefix`, family grouping)
- *      project the catalog correctly.
- *   3. Resolution — `resolveSlash` reports `not-slash` / `match` / `miss`.
- *   4. Handlers — representative core and family commands drive the right
- *      injected actions (overlay, status, dispatch, conductor) and stay thin.
- */
-export {};

package/dist/types/console/startup.d.ts

@@ -1,119 +0,0 @@
-/**
- * Startup gathering — the pure resource/notices/changelog reader the banner draws.
- *
- * The interactive console opens with a one-shot survey of what the session has to
- * work with: which context documents the agent will read, which capability cards
- * (skills) and prompt templates (commands) were discovered on disk, and a count
- * of each. This module *gathers* that survey and nothing else — it returns a
- * small, render-agnostic {@link StartupMap} the banner turns into a bordered
- * panel. It performs only read-only filesystem probes (existence checks plus the
- * briefing loaders) and holds no state; given the same disk it returns the same
- * value, so a test can drive it against a temp tree.
- *
- * It also reads (when present) a `CHANGELOG.md` at the app root and folds it into
- * a {@link StartupChangelog} the banner shows on a version bump — full on the
- * first sight of a new version, a one-line "updated to" note otherwise. The
- * decision of *which* of those to show is the gatherer's: it is handed the
- * running version and the last-seen version and reports a `mode`, so the banner
- * stays a dumb renderer.
- *
- * Nothing here imports React or Ink. The banner imports the *shapes* below and
- * the surface calls {@link gatherStartup} once at mount; the two never share
- * mutable state.
- */
-/**
- * One labelled group inside the startup map.
- *
- * A section is a title, the per-entry display lines (already shortened for the
- * terminal), and the *full* count the lines were derived from — which may exceed
- * the number of lines when the renderer elides a long list. A section with no
- * entries is omitted by {@link gatherStartup} rather than emitted empty.
- */
-export interface StartupSection {
-    /** The group heading (e.g. `"Context"`, `"Skills"`). */
-    readonly title: string;
-    /** The display lines, one per surfaced entry, already path-shortened. */
-    readonly lines: readonly string[];
-    /** How many entries the section spans (>= `lines.length`). */
-    readonly count: number;
-}
-/**
- * The gathered survey the banner renders as the "Startup Map" panel.
- *
- * A flat ordered list of {@link StartupSection}s. Empty when nothing was found,
- * in which case the banner renders no panel at all.
- */
-export interface StartupMap {
-    /** The discovered sections, in display order. */
-    readonly sections: readonly StartupSection[];
-}
-/**
- * The changelog survey the banner may render as a "What is new" block.
- *
- *   - `mode: "none"`     — no changelog to show (no file, or no version change).
- *   - `mode: "full"`     — the running version is newer than last-seen *and* the
- *     full body is worth showing; `markdown` carries it.
- *   - `mode: "condensed"`— a version change with no body to expand (or the body
- *     suppressed); only the one-line note is shown.
- */
-export type StartupChangelogMode = "none" | "full" | "condensed";
-/** The gathered changelog survey, with the running version it was keyed to. */
-export interface StartupChangelog {
-    /** Which of the three presentations the banner should render. */
-    readonly mode: StartupChangelogMode;
-    /** The running product version this survey was computed against. */
-    readonly version: string;
-    /** The condensed changelog body (present for `full`), markdown source. */
-    readonly markdown?: string;
-}
-/** The per-line tone a startup notice carries. */
-export type StartupNoticeKind = "error" | "warning" | "info";
-/** One out-of-band notice the banner renders above the wordmark region. */
-export interface StartupNotice {
-    /** The tone the line is themed with. */
-    readonly kind: StartupNoticeKind;
-    /** The notice text. */
-    readonly text: string;
-}
-/** What {@link gatherStartup} is handed to compute the survey. */
-export interface StartupInputs {
-    /** The working directory the session is scoped to. */
-    readonly cwd: string;
-    /** The user's home directory (where global resources live). */
-    readonly home: string;
-    /** The running product version (for the changelog survey). */
-    readonly version: string;
-    /** The last version the user has already seen a changelog for, if any. */
-    readonly lastSeenVersion?: string;
-    /** Absolute path of the app-root `CHANGELOG.md`, if the app knows one. */
-    readonly changelogPath?: string;
-}
-/**
- * Gather the startup map: the context documents, skills, and prompt templates
- * the session opens with, each as a {@link StartupSection}. Empty sections are
- * dropped, so a brand-new checkout with nothing on disk yields `{ sections: [] }`
- * and the banner renders no panel.
- *
- * Pure with respect to its {@link StartupInputs}: only read-only filesystem
- * probes, no writes, no caching.
- *
- * @param inputs the roots and version context to survey against
- */
-export declare function gatherStartup(inputs: StartupInputs): StartupMap;
-/**
- * Gather the changelog survey for the banner.
- *
- * The presentation depends on the version delta:
- *   - no `CHANGELOG.md`, or the running version equals the last-seen version →
- *     `mode: "none"` (nothing shown);
- *   - a version change with a non-empty condensed body → `mode: "full"` and the
- *     body in `markdown`;
- *   - a version change whose condensed body is empty → `mode: "condensed"` (only
- *     the one-line "updated to" note).
- *
- * When the app does not track a last-seen version (`lastSeenVersion` absent), a
- * present `CHANGELOG.md` is always surfaced condensed so the note still appears.
- *
- * @param inputs the version context and optional changelog path
- */
-export declare function gatherChangelog(inputs: StartupInputs): StartupChangelog;

package/dist/types/console/theme/adapter.d.ts

@@ -1,79 +0,0 @@
-/**
- * Theme adapter binding — the single boundary where the console's semantic
- * tokens become concrete terminal colours.
- *
- * The framework renders colour through an {@link InkThemeAdapter}: a `colors`
- * Record plus chalk-backed `color(key, text)` / `background(key, …)` / `dim` /
- * `muted` helpers, all produced by `createThemeAdapter(name, colors)`. The
- * framework components look colours up by *their* key vocabulary (`accent`,
- * `error`, `success`, `warning`, `borderMuted`, `bashBorder`, `userMessage`,
- * `customMessage`, `text`, `dim`, `muted`). This module is the one place those
- * framework keys are populated — each from a console {@link ThemeTokens} role —
- * so the rest of the console never speaks the framework's key names and the
- * framework never sees a console role name.
- *
- * Keeping this mapping behind a single function means the config-load step calls
- * it exactly once per scheme; the resulting adapter is then threaded as the
- * `theme` prop through every framework component the surface mounts.
- */
-import type { InkThemeAdapter, ThemeTokens } from "../contract";
-/**
- * Project the console's semantic tokens onto the framework's colour-key Record.
- *
- * The keys here are the framework's own (the names its react-ink components pass
- * to `theme.color(...)` / `theme.background(...)`), each filled from a console
- * role. The framework's `createThemeAdapter` falls back gracefully for any key
- * it asks for that is absent, but we populate every key the shipped components
- * are known to request so nothing degrades to a default grey.
- *
- *   framework key   ← console role
- *   --------------    ------------------------------------------------
- *   text            ← bodyText      (default foreground / adapter fallback)
- *   dim             ← mutedText     (the adapter's `dim()` source)
- *   muted           ← mutedText     (the adapter's `muted()` source)
- *   accent          ← signal        (primary accent the components highlight in)
- *   borderMuted     ← quietFrame    (de-emphasised borders/separators)
- *   bashBorder      ← frame         (the bash-block border tone)
- *   userMessage     ← "" (no background, plain text)
- *   customMessage   ← cardAccent    (custom/plugin message background tint)
- *   success         ← affirm
- *   warning         ← caution
- *   error           ← alarm
- *   info            ← notice        (informational status tone)
- *   highlight       ← inkText       (high-contrast on-accent text)
- *
- * Plus the markdown / diff / syntax-highlight role keys the framework's rich
- * render path (`theme.role(...)` / `theme.roleBackground(...)`) resolves. These
- * key names match the framework adapter's default role → key map exactly, so the
- * styled transcript, colored diffs, and fenced-code highlighting resolve their
- * colours straight from the console's derived tokens:
- *
- *   codeInline      ← codeInline      (inline `code` foreground)
- *   heading         ← heading         (markdown heading foreground)
- *   blockquoteBar   ← blockquoteBar   (dim quote bar)
- *   diffAddedBg     ← diffAddedBg     (added-line background tint)
- *   diffRemovedBg   ← diffRemovedBg   (removed-line background tint)
- *   diffAddedText   ← diffAddedText   (added foreground / `+`)
- *   diffRemovedText ← diffRemovedText (removed foreground / `-`)
- *   synKeyword      ← synKeyword      (syntax: keywords)
- *   synString       ← synString       (syntax: strings)
- *   synNumber       ← synNumber       (syntax: numbers)
- *   synComment      ← synComment      (syntax: comments)
- *   synType         ← synType         (syntax: types / classes)
- *
- * @param tokens the derived semantic token map for a scheme
- * @returns a flat colour Record keyed by the framework's vocabulary
- */
-export declare function frameworkColors(tokens: ThemeTokens): Record<string, string>;
-/**
- * Build the framework {@link InkThemeAdapter} for a scheme from its tokens.
- *
- * The boundary call: derive the framework colour Record from the console's
- * semantic tokens, then hand it to `createThemeAdapter` under the scheme's name.
- * This is the *only* place `createThemeAdapter` is invoked for a console theme.
- *
- * @param schemeName the scheme identity, used as the adapter's `name`
- * @param tokens     the derived semantic token map for that scheme
- * @returns the chalk/ink-backed framework adapter
- */
-export declare function themeAdapter(schemeName: string, tokens: ThemeTokens): InkThemeAdapter;

package/dist/types/console/theme/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * Console theme engine — public barrel.
- *
- * The theme engine turns the console's own re-derived accent ramps into the
- * framework {@link InkThemeAdapter} every component renders against. The
- * pipeline is: a raw {@link ThemePalette} (this module's own hex ramp) →
- * semantic {@link ThemeTokens} via {@link deriveTokens} → a framework adapter
- * via {@link themeAdapter} → a fully resolved {@link ConsoleTheme}. The two
- * built-in schemes are assembled once into {@link THEMES} and obtained through
- * {@link resolveTheme}.
- *
- * Consumers import from `src/console/theme` and never reach into the individual
- * palette/tokens/adapter/resolve modules.
- */
-export { SAFFRON_PALETTE, MIDNIGHT_PALETTE, DAYLIGHT_PALETTE, MIDNIGHT_CB_PALETTE, DAYLIGHT_CB_PALETTE, PALETTES, } from "./palette";
-export { deriveTokens } from "./tokens";
-export { themeAdapter, frameworkColors } from "./adapter";
-export { THEMES, THEME_SCHEMES, resolveTheme } from "./resolve";