@cruxy/cli 1.0.3 → 1.0.5

package/dist/checkpoint/set.d.ts

@@ -1,44 +0,0 @@
-import type { CheckpointSet, RollbackApplied, SetRollbackApplied } from "./types.js";
-/**
- * Multi-root rollback sets (C.26). A run that mutates N repos produces one
- * per-root checkpoint plus a {@link CheckpointSet} that ties them together, so
- * `cruxy rollback` restores exactly the touched roots as one gated operation.
- *
- * Two guarantees live here:
- *   • **exactly the touched roots** — the applier iterates ONLY `set.members`, so
- *     an untouched root (absent from the set) is never opened;
- *   • **stop-and-report, never silent partial** (R3) — validate every member up
- *     front (missing/corrupt → `CHECKPOINT_SET_INCOMPLETE`), then apply
- *     sequentially and STOP on the first failure, throwing
- *     `CHECKPOINT_SET_PARTIAL` with the exact restored-vs-not split.
- */
-/** `run-<utc-stamp>-<rand>` — sortable, collision-safe enough for a local CLI. */
-export declare function newRunId(): string;
-/** The set-manifest directory under the PRIMARY root (⚖︎#7). */
-export declare function setDir(primaryRoot: string): string;
-/** Persist a set manifest (atomic temp-then-rename), self-ignoring from git. */
-export declare function writeSet(primaryRoot: string, set: CheckpointSet): Promise<void>;
-/** Read a set manifest, or throw `CHECKPOINT_SET_INCOMPLETE` if missing/corrupt. */
-export declare function readSet(primaryRoot: string, runId: string): Promise<CheckpointSet>;
-/** List all set manifests under the primary root, newest first. */
-export declare function listSets(primaryRoot: string): Promise<CheckpointSet[]>;
-/**
- * One root's rollback, pre-validated (its plan already computed): `restore`
- * actually applies it. The orchestrator builds one per member.
- */
-export interface MemberRollback {
-    rootName: string;
-    restore: () => Promise<RollbackApplied>;
-}
-/**
- * Apply an all-roots rollback: run each member's `restore` in order and STOP on
- * the first failure (R3). On success, returns the restored-vs-per-root summary.
- * On failure, throws `CHECKPOINT_SET_PARTIAL` naming the roots restored (before
- * the failure) and those not restored (the failing one + all not-yet-attempted)
- * — so a partial rollback can never be reported as success, and re-running (which
- * recomputes each root from disk) safely finishes the job.
- *
- * The applier only ever touches roots present in `rollbacks`; an untouched root
- * (never added to the set) is structurally impossible to open here.
- */
-export declare function applySetRollback(runId: string, rollbacks: readonly MemberRollback[]): Promise<SetRollbackApplied>;

package/dist/checkpoint/shadow-store.d.ts

@@ -1,23 +0,0 @@
-import type { CaptureFile, CheckpointStore, FileEntry } from "./types.js";
-/**
- * Shadow-copy checkpoint content store (C.32 fallback substrate): used outside
- * a git repo, or when git plumbing fails mid-snapshot. File contents live in a
- * content-addressed pool at `.cruxy/checkpoints/objects/<sha256>` — identical
- * content across files or checkpoints is stored once, and pruning sweeps
- * objects no longer referenced by any surviving manifest.
- *
- * Writes are temp-file-then-rename so a crash can never leave a torn object; a
- * torn *read* is impossible because an object either exists complete or not at
- * all, and a missing object fails loudly.
- */
-export declare class ShadowCheckpointStore implements CheckpointStore {
-    readonly kind: "shadow";
-    private readonly objectsDir;
-    constructor(root: string);
-    hashContent(content: Buffer): string;
-    snapshot(files: CaptureFile[]): Promise<FileEntry[]>;
-    readContent(entry: FileEntry): Promise<Buffer>;
-    collect(referenced: ReadonlySet<string>): Promise<void>;
-    /** Content-addressed write: skip if present, else temp-then-rename (atomic). */
-    private writeObject;
-}

package/dist/checkpoint/types.d.ts

@@ -1,164 +0,0 @@
-/**
- * Working-tree checkpoints (C.32): a complete snapshot of everything the agent
- * could touch, captured before a run's first mutation, so `cruxy rollback` can
- * undo the entire run — creates, edits, deletes — in one gated operation.
- *
- * Two layers, deliberately separated:
- *   • {@link CheckpointStore} — the *content substrate* (where file bytes
- *     live), swappable like VectorStore: git-object-backed in a repo, a
- *     content-addressed shadow copy otherwise.
- *   • The manifest — uniform JSON under `.cruxy/checkpoints/`, owned by the
- *     service regardless of substrate, so list/prune/rollback never care which
- *     store wrote a checkpoint.
- *
- * Explicit boundary: checkpoints cover WORKING-TREE file state only. They can
- * never undo git commits, pushes, or PRs made during a run (C.15) — that is
- * stated in the rollback preview, not silently implied.
- */
-/** A file selected for capture: project-relative POSIX path + where it is on disk. */
-export interface CaptureFile {
-    path: string;
-    absPath: string;
-}
-/** Which content substrate a checkpoint was written with. */
-export type CheckpointStoreKind = "git" | "shadow";
-/**
- * One captured file in a checkpoint manifest. `oid` is the content address in
- * the store that wrote it: a git blob sha-1 for the git store, a sha-256 for
- * the shadow store. `mode` preserves the executable bit across restore.
- */
-export interface FileEntry {
-    path: string;
-    mode: "100644" | "100755";
-    oid: string;
-}
-/** A persisted checkpoint: identity, provenance, and the full pre-run manifest. */
-export interface Checkpoint {
-    /** Stable id, e.g. `ck-20260703T141530-a4f2`. */
-    id: string;
-    /** ISO-8601 creation time. */
-    createdAt: string;
-    /** One line describing the run this checkpoint protects. */
-    runSummary: string;
-    store: CheckpointStoreKind;
-    /** Every file that existed (and was capturable) before the run's first mutation. */
-    files: FileEntry[];
-    /**
-     * Project-relative paths the tracked run mutated through file tools, recorded
-     * as the run proceeds. At rollback time, a difference on a path NOT in this
-     * list is an *external* change — surfaced loudly in the preview.
-     */
-    touchedPaths: string[];
-    /**
-     * True when the run executed approved shell commands: a shell command can
-     * touch any path, so per-file attribution becomes impossible and the preview
-     * says so instead of guessing.
-     */
-    hasShellMutations: boolean;
-}
-/**
- * The content substrate seam. Implementations persist and retrieve file
- * *contents* only — manifests are the service's job.
- *
- * THE invariant (git store): snapshot/read must never disturb user-visible git
- * state — HEAD, the index, the stash, or any ref. The git store self-checks
- * this at runtime and fails loudly on drift.
- */
-export interface CheckpointStore {
-    readonly kind: CheckpointStoreKind;
-    /** Persist the current contents of `files`; returns the manifest entries. */
-    snapshot(files: CaptureFile[]): Promise<FileEntry[]>;
-    /** The content address `snapshot` would give this buffer (for diffing). */
-    hashContent(content: Buffer): string;
-    /** Read one captured file's bytes back. Throws CRUXY_E_CHECKPOINT_FAILED if gone. */
-    readContent(entry: FileEntry): Promise<Buffer>;
-    /**
-     * Best-effort GC after prune: drop stored content whose oid is no longer
-     * referenced by any surviving manifest. The git store is a no-op (dangling
-     * objects belong to git's own gc); the shadow store sweeps its object pool.
-     */
-    collect(referenced: ReadonlySet<string>): Promise<void>;
-}
-/** What rollback will do to one path. */
-export type RollbackAction = 
-/** The run deleted it — recreate from the checkpoint. */
-"recreate"
-/** The run edited it — revert content (and mode) to the checkpoint. */
- | "revert"
-/** The run created it — delete it. */
- | "delete";
-export interface RollbackEntry {
-    path: string;
-    action: RollbackAction;
-    /**
-     * True when this path changed since the checkpoint but the tracked run never
-     * touched it — concurrent user (or other-tool) work that rollback would
-     * clobber. Always surfaced in the preview; never overwritten silently.
-     */
-    external: boolean;
-    /** Checkpoint-side content to restore (recreate/revert; absent for delete). */
-    entry?: FileEntry;
-}
-/** The computed diff between the current working tree and a checkpoint. */
-export interface RollbackPlan {
-    checkpoint: Checkpoint;
-    /** Sorted by path; empty means the tree already matches the checkpoint. */
-    entries: RollbackEntry[];
-    /** The `external: true` paths, for the preview's warning block. */
-    externalPaths: string[];
-    /** Mirrors {@link Checkpoint.hasShellMutations}: attribution is unknowable. */
-    attributionUnknown: boolean;
-}
-/** Counts of what a successful rollback actually did. */
-export interface RollbackApplied {
-    recreated: number;
-    reverted: number;
-    deleted: number;
-}
-/**
- * One touched root inside a {@link CheckpointSet}: the declared root's name (for
- * attribution in the preview), its absolute path, and the id of the per-root
- * checkpoint that protects it. There is exactly ONE member per root the run
- * mutated — an untouched root has no member and is never opened at rollback.
- */
-export interface CheckpointSetMember {
-    /** Declared workspace-root name (shown in the grouped preview). */
-    rootName: string;
-    /** Absolute path of the root (where its `.cruxy/checkpoints/` live). */
-    rootPath: string;
-    /** The checkpoint id within that root. */
-    checkpointId: string;
-}
-/**
- * A run's rollback unit across N repos (C.26). `cruxy rollback` restores **all
- * members** of a set as one gated operation — exactly the roots the run touched,
- * no more (untouched roots are absent) and no less (a touched root missing its
- * member is a loud `CRUXY_E_CHECKPOINT_SET_INCOMPLETE`, never a silent partial).
- *
- * The set manifest lives under the PRIMARY root's `.cruxy/checkpoints/sets/`, so
- * it travels with the workspace and survives `rm -rf ~/.cruxy`. The member
- * checkpoints themselves live in each root, exactly as in the single-root case.
- */
-export interface CheckpointSet {
-    /** Stable run id, e.g. `run-20260708T031500-a4f2`. */
-    runId: string;
-    /** ISO-8601 creation time (of the set, i.e. the run's first mutation). */
-    createdAt: string;
-    /** One line describing the run this set protects. */
-    runSummary: string;
-    /** One entry per TOUCHED root. */
-    members: CheckpointSetMember[];
-}
-/**
- * The outcome of a successful all-roots rollback: which roots were restored and
- * what each did. On a mid-apply failure this is NOT returned — a
- * `CRUXY_E_CHECKPOINT_SET_PARTIAL` is thrown instead, carrying the restored-vs-not
- * split (R3), so a partial can never read as success.
- */
-export interface SetRollbackApplied {
-    runId: string;
-    /** Root names restored, in apply order. */
-    restored: string[];
-    /** Per-root counts, keyed by root name. */
-    perRoot: Record<string, RollbackApplied>;
-}

package/dist/cli/commands/checkpoint.d.ts

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy checkpoint` (C.32) — inspect the working-tree snapshots that back
- * `cruxy rollback`. Creation is automatic (before a run's first mutation);
- * this command only lists.
- */
-export declare function checkpointCommand(): Command;

package/dist/cli/commands/config.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function configCommand(): Command;

package/dist/cli/commands/hooks.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy hooks` — inspect and trust hooks + custom slash commands (C.19).
- * `list` shows the resolved catalog (including which project hooks are trusted
- * and any malformed definitions); `trust <path>` records the explicit,
- * reviewed decision to run a project's hooks, bound to their current fingerprint.
- */
-export declare function hooksCommand(): Command;

package/dist/cli/commands/index.d.ts

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy index` — build or refresh the local codebase search index that backs
- * the `search_codebase` tool. `--status` reports the current state without
- * modifying it; `--force` re-embeds every file regardless of content hashes.
- */
-export declare function indexCommand(): Command;

package/dist/cli/commands/init.d.ts

@@ -1,7 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy init` — set up a project (U.6): ensure a key (acquired only if missing),
- * offer to scaffold a project `CRUXY.md`, and offer a first-win demo run. Like
- * `login`, it's interactive-only.
- */
-export declare function initCommand(): Command;

package/dist/cli/commands/login.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy login` — set or replace the API key on demand (U.6). Runs the key step
- * of onboarding (always, even if a key already resolves — this is how you
- * re-key / switch), validates it live, and persists it to the credentials store.
- * Non-interactive invocations fail loud rather than hang.
- */
-export declare function loginCommand(): Command;

package/dist/cli/commands/mcp.d.ts

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy mcp` — inspect and control MCP server integration (C.27). `list` shows
- * the configured servers and whether this repo's config is trusted; `trust`
- * records the explicit decision to connect them, bound to the current config
- * fingerprint. Trusting a server runs its code UNSANDBOXED with your privileges,
- * so `trust` restates that plainly before recording.
- */
-export declare function mcpCommand(): Command;

package/dist/cli/commands/memory.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy memory` — inspect and control persistent memory (C.29). `list` shows
- * user + project entries and whether project memory is trusted (recalled);
- * `forget`/`clear` remove entries; `trust` records the explicit decision to
- * recall a repo's project memory, bound to its current fingerprint.
- */
-export declare function memoryCommand(): Command;

package/dist/cli/commands/pr.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy pr` — turn the current changes into a pull request (C.15). Generates the
- * branch name, conventional commit, and PR title/body from the diff with the
- * model, then runs branch → commit → push → open-PR behind the one U.3 approval.
- * The forge token comes from the environment / `gh`; it's never prompted or stored.
- */
-export declare function prCommand(): Command;

package/dist/cli/commands/rollback.d.ts

@@ -1,18 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy rollback [id]` (C.32/C.26) — restore the working tree to a run's
- * checkpoint(s), undoing everything an agent run changed in one operation.
- * Destructive by definition, so it is preview-first and gated through U.3 at the
- * destructive tier, ungrantable; non-TTY is refused with a coded error before
- * anything is computed. Out of scope, stated in the preview: commits, pushes, and
- * PRs made during the run are not undone.
- *
- * Routing:
- *   • an explicit `<id>` that names a run/JOB set (C.28: a background job's id) →
- *     set-based rollback of exactly that run, restoring every root it touched;
- *   • an explicit `<id>` that is a checkpoint id → single-root rollback (escape
- *     hatch; also the recovery route if the primary root's set index was removed);
- *   • no id, a set manifest exists → set-based rollback of the latest run;
- *   • no id, no set manifest → JC-F fallback to legacy single-root, logged.
- */
-export declare function rollbackCommand(): Command;

package/dist/cli/commands/run.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function runCommand(): Command;

package/dist/cli/commands/skills.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy skills` — list the skills available to the agent (the same catalog the
- * `list_skills` tool sees). `--status` additionally shows the three source
- * directories in precedence order and any validation errors (skills that were
- * excluded for being malformed).
- */
-export declare function skillsCommand(): Command;

package/dist/cli/commands/test.d.ts

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy test` (C.13) — run the project's detected/configured test command
- * once and print the structured result the agent would see. Directly
- * user-invoked, so there is no approval gate (typing the command IS the
- * consent — same as running the suite by hand); the process exit code mirrors
- * the suite's pass/fail so scripts and CI can branch on it.
- */
-export declare function testCommand(): Command;

package/dist/cli/commands/usage.d.ts

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-/**
- * `cruxy usage` (C.22) — show LOCAL token usage and (when priced) cost, read
- * back from `~/.cruxy/usage`. Read-only and local: it prints your own accounting
- * and transmits nothing. Every figure is real — a request the provider never
- * reported usage for is shown as unreported, never a fabricated number, and cost
- * appears only for tiers you have priced.
- */
-export declare function usageCommand(): Command;

package/dist/cli/onboard.d.ts

@@ -1,25 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import { type OnboardingResult } from "../onboarding/index.js";
-/**
- * CLI-layer glue between the entry points and the onboarding module (U.6). Keeps
- * `run`/`program`/`login`/`init` thin: they decide *when* to onboard; this builds
- * the production wiring (live validation, credential persistence, first-win run).
- */
-/** The env var that holds the key for a provider (for the fail-loud message). */
-export declare function apiKeyEnvVar(provider: string): string;
-/** Run one first-win task end-to-end against the just-saved key. */
-export declare function runFirstWinTask(config: CruxyConfig, cwd: string, prompt: string): Promise<void>;
-export interface MaybeOnboardOptions {
-    /** Whether stdin is a TTY (the gate). */
-    ttyInteractive: boolean;
-    /** Offer the first-win demo run (no real task queued). */
-    offerFirstWin: boolean;
-    cwd: string;
-}
-/**
- * Run the guided first-run flow **iff** this is a first run; otherwise return
- * `null` so the caller can fall back (fail loud, or show a banner). Never throws
- * for an aborted setup — `result.completed` is `false` and the caller exits
- * cleanly.
- */
-export declare function maybeRunOnboarding(config: CruxyConfig, opts: MaybeOnboardOptions): Promise<OnboardingResult> | null;

package/dist/cli/program.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function buildProgram(): Command;

package/dist/cli/repl.d.ts

@@ -1,27 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-import type { Session } from "../agent/index.js";
-import type { CheckpointGate } from "../checkpoint/index.js";
-import { type SlashCommandSpec } from "../hooks/index.js";
-import { type StreamRenderer } from "../render/index.js";
-/**
- * The REPL's slash commands — the autocomplete candidate set (U.7). Keep in
- * sync with the dispatch below and the HELP text.
- */
-export declare const REPL_COMMANDS: readonly ["/help", "/clear", "/compact", "/reload", "/plan", "/jobs", "/logs", "/cancel", "/exit", "/quit"];
-/** The stdin/stdout pair the REPL reads from and prompts on. Injectable for tests. */
-export interface ReplIO {
-    input: Readable;
-    output: Writable;
-}
-/**
- * Drive an interactive multi-turn session: prompt, read a line, dispatch slash
- * commands or run a turn, repeat. Assistant text and tool-call progress stream
- * through the `renderer` from within `session.send`; this loop only owns input
- * and control.
- *
- * `io` defaults to real stdin/stdout; tests inject a scripted stream pair. The
- * renderer defaults to whatever `io.output` supports (a TTY gets the managed
- * live region, anything else the plain append-only renderer); `cruxy run`
- * passes its own so the approval prompt's status-suspend hook shares it.
- */
-export declare function runInteractive(session: Session, io?: ReplIO, renderer?: StreamRenderer, checkpoints?: CheckpointGate, slashCommands?: readonly SlashCommandSpec[]): Promise<void>;

package/dist/cli/session-factory.d.ts

@@ -1,42 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import { withCheckpointGate } from "../checkpoint/index.js";
-import type { CheckpointGate } from "../checkpoint/index.js";
-export { withCheckpointGate };
-import type { SandboxService } from "../sandbox/index.js";
-import type { StreamRenderer } from "../render/index.js";
-import { ToolRegistry, type Tool } from "../tools/index.js";
-import { Session, type LifecycleHookRunner } from "../agent/index.js";
-import type { Workspace } from "../workspace/index.js";
-/**
- * Register every CONDITIONALLY-enabled runtime tool onto `registry`, in the fixed
- * order the model sees them: `remember` (memory), the four LSP tools, the two web
- * tools, the trusted MCP tools, then `spawn_subagent`. Factored out of
- * {@link buildAgentSession} for ONE reason beyond tidiness: it makes the *complete
- * runtime* tool set enumerable by a test (JC-B). The default registry only covers
- * the 14 always-on tools; the allowlist test that pins "no tool can add a workspace
- * root" is only sound if it runs against the SAME set the session ships — so the
- * session factory and that test both build the surface through this one seam. A new
- * conditionally-registered tool added here fails the allowlist test until it is
- * consciously listed and audited.
- *
- * Each family is opt-in and inert when its feature flag is off, exactly as before —
- * this function is a pure move of the inline registration, same guards, same order.
- * `spawnTool` is passed in (already depth-bound) because it needs the orchestrator;
- * it registers only when nesting is allowed (`subagent.maxDepth > 0`).
- */
-export declare function registerRuntimeTools(registry: ToolRegistry, config: CruxyConfig, opts?: {
-    mcpTools?: Tool[];
-    spawnTool?: Tool;
-    spawnManyTool?: Tool;
-    jobTool?: Tool;
-}): void;
-/**
- * Build a ready-to-run agent {@link Session} from a resolved key — the wiring
- * shared by `cruxy run` and the onboarding first-win task (so they can't drift).
- * The approval gate's interactivity tracks the TTY, exactly as in `run`.
- *
- * When `planMode` is on (C.31), it additionally wires a {@link PlanExecutionPolicy}
- * over the shared U.3 allowlist and a `planRunner` so `session.send` proposes →
- * approves → executes. Plan mode is fully opt-in; the default path is unchanged.
- */
-export declare function buildAgentSession(config: CruxyConfig, apiKey: string, workspace: Workspace, ttyInteractive: boolean, planMode?: boolean, renderer?: StreamRenderer, checkpoints?: CheckpointGate, sandbox?: SandboxService, hooks?: LifecycleHookRunner, mcpTools?: Tool[]): Session;

package/dist/cli/stream-print.d.ts

@@ -1,14 +0,0 @@
-/**
- * Wrap a raw write sink into a printer for streamed assistant text.
- *
- * Models routinely begin a turn with one or more leading newlines; written
- * verbatim those land as blank lines between the prompt and the answer. The
- * printer drops the leading newline run of a turn (until the first visible
- * character) so output starts on a single fresh line, and otherwise forwards
- * text untouched — internal blank lines (markdown paragraphs, code) are
- * preserved. State is per printer, so create one per turn.
- *
- * All turn output — the deltas and the loop's single segment-terminating
- * newline — flows through this one sink, so nothing races the stream on stdout.
- */
-export declare function createStreamPrinter(write: (text: string) => void): (delta: string) => void;

package/dist/components/autocomplete.d.ts

@@ -1,32 +0,0 @@
-/**
- * Autocomplete (U.7): pure completion over an injectable candidate list, plus
- * the readline adapter the REPL uses for Tab-completion. Non-destructive by
- * construction — this module transforms strings and returns suggestions; it
- * has no access to the session, so completing can never execute anything.
- * Enter (the existing REPL path) remains the only way to act.
- */
-/** The outcome of one completion attempt. */
-export interface Completion {
-    /** The (possibly extended) input line. Unchanged when nothing matches. */
-    line: string;
-    /** Every candidate the input currently prefixes (shown on ambiguity). */
-    suggestions: string[];
-}
-/**
- * Complete `line` against `candidates` (exact-prefix filter):
- * - no match → line unchanged, no suggestions;
- * - one match → completed fully to it;
- * - several → extended to their longest common prefix, all listed.
- * Pure data in, data out — deterministic and order-preserving.
- */
-export declare function completeLine(line: string, candidates: readonly string[]): Completion;
-/**
- * A Node-readline `completer` over a live candidate source. Only the leading
- * word of a line starting with `/` completes (slash commands); everything
- * else — prompts to the model — is left alone, so Tab never mangles prose.
- *
- * readline's contract: return `[hits, prefixBeingReplaced]`; readline itself
- * extends to the common prefix and lists hits on a second Tab. It rewrites
- * only the edit buffer — submission stays on Enter.
- */
-export declare function makeReplCompleter(candidates: () => readonly string[]): (line: string) => [string[], string];

package/dist/components/frame.d.ts

@@ -1,28 +0,0 @@
-import { stripAnsi } from "../render/layout.js";
-import type { RenderCapabilities } from "../render/index.js";
-/** The visible text of a possibly-styled row (re-exported from the U.12 home). */
-export { stripAnsi };
-/**
- * The transient multi-line region interactive components draw into (U.7) —
- * the multi-row analog of the TTY renderer's single managed status line, with
- * the same discipline:
- *
- * - Only the frame is ever rewritten (erase + redraw in place) — committed
- *   output above it is never touched.
- * - Every line is hard-truncated to the terminal width so a row can never
- *   soft-wrap; wrapped rows would break erasure and leave artifacts.
- * - `clear()` removes the frame entirely — after a component resolves, the
- *   screen holds zero leftover bytes from the interaction.
- * - On resize (U.12) the frame reflows its current rows in place at the new
- *   width; committed output above is untouched. `clear()` also unsubscribes.
- *
- * Requires cursor control (`caps.cursor`); components guard on that before
- * constructing one.
- */
-export interface Frame {
-    /** Repaint the frame with these rows (erases the previous paint first). */
-    render(lines: string[]): void;
-    /** Erase the frame completely and release the resize subscription. Idempotent. */
-    clear(): void;
-}
-export declare function createFrame(write: (text: string) => void, caps: RenderCapabilities): Frame;

package/dist/components/fuzzy.d.ts

@@ -1,61 +0,0 @@
-import { type Theme } from "../theme/index.js";
-import { type ComponentIO, type InteractiveResult } from "./input.js";
-/**
- * Fuzzy finding (U.7): a deterministic, honest subsequence scorer (pure,
- * headless-tested) plus the interactive type-to-filter component built on it.
- * No fabricated relevance — a label either contains the query as a
- * subsequence or it does not, and the score is three documented bonuses.
- */
-/** A successful match: its rank score and the label indices that matched. */
-export interface FuzzyMatch {
-    score: number;
-    /** Indices into the label of the matched characters (for highlighting). */
-    positions: number[];
-}
-/**
- * Case-insensitive greedy-leftmost subsequence match.
- * - Empty query matches everything: score 0, no positions (nothing to
- *   highlight, nothing to fabricate).
- * - Not a subsequence → `null`.
- * - Score = Σ per matched char: {@link BASE} + {@link CONSECUTIVE} when the
- *   match continues a run + {@link BOUNDARY} when it starts a word.
- * Deterministic by construction — same inputs, same output, no randomness,
- * no length normalization (ties break in {@link rankItems}).
- */
-export declare function fuzzyScore(query: string, label: string): FuzzyMatch | null;
-/** An item that survived filtering, with everything the finder renders. */
-export interface RankedItem<T> {
-    item: T;
-    label: string;
-    match: FuzzyMatch;
-}
-/**
- * Filter + rank a list against a query. Ordering is fully stable and
- * deterministic: score descending, then shorter label, then original index.
- * An empty query returns every item in original order.
- */
-export declare function rankItems<T>(items: readonly T[], toLabel: (item: T) => string, query: string): RankedItem<T>[];
-/**
- * Bold the matched characters of a label via the theme's accent role. With
- * color off (NO_COLOR, pipe) the roles are identity — plain text, zero ANSI.
- */
-export declare function highlightMatch(label: string, positions: readonly number[], theme: Theme): string;
-export interface FuzzyFindOptions<T> {
-    /** Label an item filters/renders under. Required — items are opaque. */
-    toLabel: (item: T) => string;
-    /** Header above the query line (e.g. "pick a checkpoint"). */
-    title?: string;
-    /** Non-TTY fallback: resolve to this instead of failing loud. */
-    defaultValue?: T;
-    /** `--flag` alternatives listed in the non-TTY error. */
-    nonInteractiveHint?: string[];
-    /** Visible result rows before the list scrolls (default 10). */
-    maxVisible?: number;
-}
-/**
- * Interactive fuzzy finder: type to filter, ↑/↓ to move through the ranked
- * results, Enter to select the highlighted item (inert while there are no
- * matches), Esc / Ctrl-C / EOF to cancel. The transient frame is fully erased
- * before resolving — the screen keeps no trace of the interaction.
- */
-export declare function fuzzyFind<T>(items: readonly T[], opts: FuzzyFindOptions<T>, io?: ComponentIO): Promise<InteractiveResult<T>>;

package/dist/components/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./keys.js";
-export * from "./input.js";
-export * from "./frame.js";
-export * from "./select.js";
-export * from "./fuzzy.js";
-export * from "./autocomplete.js";