indusagi-coding-agent 0.1.58 → 0.1.60

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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,119 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+/**
+ * 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     ← promptSurface (user-turn background tint)
+ *   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)
+ *
+ * @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

@@ -0,0 +1,18 @@
+/**
+ * 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 { MIDNIGHT_PALETTE, DAYLIGHT_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

@@ -0,0 +1,42 @@
+/**
+ * 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 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

@@ -0,0 +1,45 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+/**
+ * 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 {};

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

@@ -0,0 +1,40 @@
+/**
+ * Token derivation — expand a raw {@link ThemePalette} into the semantic
+ * {@link ThemeTokens} the console actually renders against.
+ *
+ * The console body never names a hex or a palette stop; it names a *role*
+ * (`signal`, `frame`, `bodyText`, `alarm`, …). This module is the one place the
+ * thirteen roles are bound to ramp stops. The mapping is pure and total: every
+ * key of {@link ThemeTokens} is assigned exactly once from a {@link ThemePalette}
+ * field, so a ramp that is missing a stop fails to type-check rather than
+ * producing an undefined colour at render time.
+ *
+ * Role → stop assignments (identical structure for both schemes; the schemes
+ * differ only in the underlying ramp):
+ *
+ *   - `signal`        ← `primary`    (the dominant accent: focus, selection)
+ *   - `frame`         ← `tertiary`   (default structural border lines)
+ *   - `quietFrame`    ← `muted`      (de-emphasised separators)
+ *   - `promptSurface` ← `secondary`  (the composer's active tint)
+ *   - `cardAccent`    ← `secondary`  (row gutters and headers)
+ *   - `bodyText`      ← `body`       (default answer foreground)
+ *   - `mutedText`     ← `muted`      (timestamps, hints, metadata)
+ *   - `inkText`       ← `ink`        (high-contrast text on an accent)
+ *   - `notice`        ← `tertiary`   (informational tone)
+ *   - `affirm`        ← `affirm`     (success tone)
+ *   - `caution`       ← `caution`    (warning tone)
+ *   - `alarm`         ← `alarm`      (error/fault tone)
+ *   - `pending`       ← `primary`    (busy/in-flight tone)
+ */
+import type { ThemePalette, ThemeTokens } from "../contract";
+/**
+ * Map a raw accent ramp onto the closed semantic token set.
+ *
+ * Pure and deterministic: the same palette always yields the same tokens, and
+ * the returned object is a fresh frozen value the resolver can cache. The role
+ * assignments are shared by both schemes — only the ramp handed in differs.
+ *
+ * @param palette the raw nine-stop ramp for a scheme
+ * @returns the thirteen-role semantic token map
+ */
+export declare function deriveTokens(palette: ThemePalette): ThemeTokens;

package/dist/types/entry.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Process entry point — the bin the OS launches.
+ *
+ * Responsibilities, in order:
+ *   1. Set `process.title` to the brand's primary bin name so the process is
+ *      identifiable in `ps` / activity monitors.
+ *   2. Install exactly one console filter that suppresses the transport-layer
+ *      `[MCP]` noise the MCP stack emits on stdout/stderr (unless the brand's
+ *      debug env var is set, in which case nothing is filtered).
+ *   3. Hand the sliced `argv` to {@link boot} and adopt its resolved exit code.
+ *
+ * The boot call is guarded by an `import.meta` entry check so importing this
+ * module (e.g. from a test) does not launch the agent — only running it as the
+ * program entry does.
+ */
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Package root barrel — the public library surface of the indusagi coding agent.
+ *
+ * The terminal binary is `entry.ts` (the `indus` / `indusagi` bin). This barrel
+ * exposes each subsystem as a namespace for embedding or testing. The agent
+ * depends only on the `indusagi` framework package.
+ */
+export * as boot from "./boot";
+export * as workspace from "./workspace";
+export * as conductor from "./conductor";
+export * as windowBudget from "./window-budget";
+export * as capabilityDeck from "./capability-deck";
+export * as runtimeBridge from "./runtime-bridge";
+export * as addons from "./addons";
+export * as consoleUi from "./console";
+export * as channels from "./channels";
+export * as briefing from "./briefing";
+export * as transcriptExport from "./transcript-export";
+export * as launch from "./launch";
+export * as insight from "./insight";
+export * as kit from "./kit";
+export * as settings from "./settings";
+export * as sessions from "./sessions";
+export declare const VERSION = "0.1.60";

package/dist/types/insight/channel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Signal channel — the in-memory pipe between the recorder and the sinks.
+ *
+ * The recorder *pushes* {@link Signal}s the instant a probe opens, updates, or
+ * closes; a {@link Sink} *pulls* a {@link SignalStream} (an
+ * `AsyncIterable<Signal>`) and drains it at its own pace. A
+ * {@link SignalChannel} bridges those two models: it is an unbounded
+ * push-to-pull queue with back-pressure expressed by pull latency.
+ *
+ * Mechanics: when a consumer is parked in `next()` awaiting a value, an emitted
+ * signal resolves its promise immediately (no buffering). When no consumer is
+ * waiting, the signal is appended to an internal buffer and handed out in FIFO
+ * order on the next pull. Closing the channel makes the iterator finish once the
+ * buffer drains. The channel multiplexes: every call to {@link stream} returns an
+ * independent iterator, and each emitted signal is fanned out to all of them, so
+ * the console, file, and network sinks can each drain the same trail.
+ */
+import { SignalEmit, SignalStream } from "./contract";
+/**
+ * A fan-out push-to-pull pipe of {@link Signal}s.
+ *
+ * The recorder holds the {@link SignalChannel.emit} end; each sink holds a
+ * {@link SignalStream} obtained from {@link SignalChannel.stream}. Producers
+ * never block: emitting onto a channel with no parked consumer just buffers.
+ */
+export interface SignalChannel {
+    /** Push one signal to every attached subscriber. A no-op once closed. */
+    readonly emit: SignalEmit;
+    /** Attach a new independent consumer; returns its pull-model stream. */
+    stream(): SignalStream;
+    /** How many subscribers are currently attached. */
+    readonly size: number;
+    /** Whether {@link close} has been called. */
+    readonly closed: boolean;
+    /** Finish every attached stream once its buffer drains. Idempotent. */
+    close(): void;
+}
+/**
+ * Create a fresh, empty {@link SignalChannel}.
+ *
+ * The returned channel starts with no subscribers; call {@link SignalChannel.stream}
+ * once per sink before emitting if those sinks must observe the first signal.
+ * (A subscriber only receives signals emitted after it attaches.)
+ */
+export declare function createChannel(): SignalChannel;