indusagi-coding-agent 0.2.3 → 0.2.5

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";

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

@@ -1,77 +0,0 @@
-/**
- * Theme palettes — the console's own re-derived accent ramps.
- *
- * This module owns the two raw {@link ThemePalette} values the console ships
- * with, one per {@link ThemeScheme}. A palette is the *source* nine-stop ramp a
- * scheme is built from: three accent hues (a cool primary, a warm secondary, a
- * muted support tertiary), a three-stop neutral text gradient (ink/body/muted),
- * and the three status hues (affirm/caution/alarm). Everything the console
- * renders is computed from these stops by the token derivation step — no module
- * downstream of here writes a literal hex.
- *
- * The hex values are an original ramp authored for this console. The cool
- * primary is a desaturated spring-green/teal, the warm secondary a tangerine
- * amber, and the support tertiary a soft periwinkle; the neutral gradient is a
- * cool slate. The `daylight` variant re-derives the same roles at higher
- * saturation / lower luminance so they read on a bright terminal background.
- * None of these stops reuse an upstream accent — they were picked fresh against
- * a contrast target for each role.
- */
-import type { ThemePalette, ThemeScheme } from "../contract";
-/**
- * The dark-terminal ramp.
- *
- * Cool spring-teal primary against a cool-slate neutral gradient, with a warm
- * amber secondary for contrast accents and a soft periwinkle support tone.
- */
-export declare const MIDNIGHT_PALETTE: ThemePalette;
-/**
- * The light-terminal ramp.
- *
- * The same role assignments re-derived deeper and more saturated so each hue
- * keeps its contrast against a bright background; the neutral gradient inverts
- * to a dark-on-light slate.
- */
-export declare const DAYLIGHT_PALETTE: ThemePalette;
-/**
- * The "IndusCode Saffron" dark-terminal ramp — the brand scheme.
- *
- * The console's signature look: a warm saffron primary (borders, headings, the
- * brand wordmark) against a cream neutral gradient, with a cool teal secondary
- * for the interactive accents (the prompt caret, chips, bullets) — the two hues
- * the IndusCode masthead is built from. The status hues stay warm-leaning so the
- * whole scheme reads as one saffron identity rather than a recoloured midnight.
- */
-export declare const SAFFRON_PALETTE: ThemePalette;
-/**
- * The dark-terminal color-blind-safe ramp.
- *
- * A clone of {@link MIDNIGHT_PALETTE} that re-derives the three *status* hues so
- * a red-green color-blind user (deuteran/protan, ~8% of men) can tell success
- * from failure without relying on the red-green axis. Success moves off green
- * onto a vivid blue (`affirm → #4aa3ff`); failure stays red but is deepened to a
- * darker tone (`alarm → #c83232`) so it sits well below the bright blue in
- * lightness, and the amber warning is nudged brighter — so the three status
- * tones separate by *lightness*, not hue alone. The three accent hues and the
- * neutral gradient are carried over unchanged from the base midnight ramp — only
- * the status stops move, so the overall look stays the midnight scheme.
- */
-export declare const MIDNIGHT_CB_PALETTE: ThemePalette;
-/**
- * The light-terminal color-blind-safe ramp.
- *
- * The daylight counterpart of {@link MIDNIGHT_CB_PALETTE}: clones
- * {@link DAYLIGHT_PALETTE} and remaps success to a deeper blue tuned for a
- * bright background (`affirm → #1f6fd6`), deepens the red alarm
- * (`alarm → #b02622`) for lightness separation from that blue, and darkens the
- * amber warning so the three status tones stay separable by lightness on a light
- * terminal too.
- */
-export declare const DAYLIGHT_CB_PALETTE: ThemePalette;
-/**
- * The raw ramp for each scheme, keyed by {@link ThemeScheme}.
- *
- * The token derivation step reads from this table; the resolver returns the
- * scheme whose palette it expanded.
- */
-export declare const PALETTES: Readonly<Record<ThemeScheme, ThemePalette>>;

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

@@ -1,45 +0,0 @@
-/**
- * Theme resolution — assemble the fully-resolved {@link ConsoleTheme} for each
- * scheme and expose the picker entry points.
- *
- * This is the top of the theme engine. It runs the pipeline once per scheme at
- * module load:
- *
- *   palette  ──deriveTokens──▶  tokens  ──themeAdapter──▶  framework adapter
- *      └──────────────────────────┴───────────────────────────┘
- *                          ConsoleTheme
- *
- * The two assembled themes are frozen into {@link THEMES}; {@link resolveTheme}
- * is the single sanctioned way the surface obtains the theme for a scheme name.
- * Because the heavy work (chalk adapter construction) happens here at the
- * config-load boundary, the render path only ever reads an already-built
- * {@link ConsoleTheme} — it never re-derives colours.
- */
-import { type ConsoleTheme, type ThemeScheme } from "../contract";
-/**
- * The built-in themes, fully resolved and keyed by {@link ThemeScheme}.
- *
- * Assembled once at load time from {@link PALETTES}. This is the table the
- * theme picker lists and {@link resolveTheme} reads; it is the console's
- * complete shipped theme set.
- */
-export declare const THEMES: Readonly<Record<ThemeScheme, ConsoleTheme>>;
-/**
- * Resolve a scheme name to its fully-built {@link ConsoleTheme}.
- *
- * The single entry point the surface and the loader use to turn a scheme name
- * (from settings, a slash argument, or the {@link DEFAULT_SCHEME}) into a theme.
- * An unrecognised or absent name falls back to {@link DEFAULT_SCHEME} rather
- * than throwing, so a corrupt preference never blanks the console.
- *
- * @param scheme a candidate scheme name, possibly invalid or undefined
- * @returns the resolved theme for that scheme, or the default theme
- */
-export declare function resolveTheme(scheme?: string | null): ConsoleTheme;
-/**
- * The schemes the console offers, in picker order.
- *
- * Derived from {@link THEMES} so adding a scheme to the table adds it to the
- * picker with no second list to update.
- */
-export declare const THEME_SCHEMES: readonly ThemeScheme[];

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

@@ -1,16 +0,0 @@
-/**
- * Theme engine — pure behavioural tests.
- *
- * Four concerns, all exercised without mounting Ink:
- *   1. The two ramps are valid six-digit hex and structurally complete.
- *   2. Token derivation is total and binds every semantic role to a ramp stop.
- *   3. The framework-key projection covers every key the shipped react-ink
- *      components request, sourced from the right token role.
- *   4. The resolver returns the right theme per scheme and falls back to the
- *      default for any unrecognised / missing name, and the assembled
- *      {@link ConsoleTheme} carries a live framework adapter.
- *
- * Clean-room guard: an explicit assertion that no produced hex collides with a
- * known upstream accent, enforced across both ramps and the derived tokens.
- */
-export {};