@cruxy/cli 1.0.3 → 1.0.4

package/dist/components/input.d.ts

@@ -1,78 +0,0 @@
-import type { RenderCapabilities } from "../render/index.js";
-import { type Key } from "./keys.js";
-/**
- * The one raw-mode input reader (U.7). Every interactive component — and the
- * refactored approval/onboarding key readers — reads keys through this seam;
- * nothing else in the CLI touches `setRawMode`. The lifecycle is strict:
- * `begin()` → `read()` loop → `restore()` in a `finally`, so the terminal is
- * never left in raw mode on any exit path (selection, cancel, throw).
- */
-/** The minimal stdin surface the reader needs. Injectable for tests. */
-export interface RawInput {
-    isTTY?: boolean;
-    setRawMode?(mode: boolean): unknown;
-    resume(): unknown;
-    pause(): unknown;
-    on(event: "data" | "end", listener: (chunk: Buffer) => void): unknown;
-    removeListener(event: "data" | "end", listener: (chunk: Buffer) => void): unknown;
-}
-/** Raw-mode key source with an explicit begin/read/restore lifecycle. */
-export interface KeyReader {
-    /** Enter raw mode and start decoding. Safe to call once per interaction. */
-    begin(): void;
-    /**
-     * The next decoded key. After stream end (or `restore()`), resolves
-     * `{kind:"eof"}` forever — a component's read loop can never hang or reject.
-     */
-    read(): Promise<Key>;
-    /** Leave raw mode, detach, pause. Idempotent; call in `finally`, always. */
-    restore(): void;
-}
-/** Build the real reader over `stdin` (or an injected fake in tests). */
-export declare function createKeyReader(stdin?: RawInput): KeyReader;
-/**
- * Read exactly one key with the full begin/restore lifecycle — the shared
- * backend for the approval prompt's single-key read and the onboarding
- * `readKey`. Resolves the printable character, `"\n"` for enter, and `""` for
- * anything that means "no answer" (Ctrl-C, EOF, escape, arrows) — preserving
- * the callers' default-deny mapping.
- */
-export declare function readSingleKey(stdin?: RawInput): Promise<string>;
-/**
- * Every component resolves to a selection or a clean, typed cancellation
- * (Ctrl-C / EOF / escape). Cancellation is data for the caller to interpret —
- * never a thrown error, never a partial value.
- */
-export type InteractiveResult<T> = {
-    kind: "selected";
-    value: T;
-} | {
-    kind: "cancelled";
-};
-/**
- * What a component needs from the environment, bundled so tests can script
- * all of it. `caps` is the existing U.2 capability detection — components
- * never re-probe NO_COLOR / width / TTY themselves.
- */
-export interface ComponentIO {
-    caps: RenderCapabilities;
-    /**
-     * The whole interactive contract in one flag: stdin is a TTY *and* the
-     * output supports cursor control (`TERM=dumb` fails this). When false, no
-     * frame is drawn and no key is read — ever.
-     */
-    interactive: boolean;
-    /** Transient frame bytes. Defaults to stderr so stdout stays pipe-clean. */
-    write(text: string): void;
-    keys: KeyReader;
-}
-/** The real environment: frames to stderr, keys from stdin, caps from stderr. */
-export declare function defaultComponentIO(): ComponentIO;
-/**
- * The shared non-TTY gate, run before any frame byte or key read:
- * - interactive → proceed;
- * - not interactive + a default was supplied → resolve to it immediately;
- * - otherwise → throw `CRUXY_E_INTERACTIVE_REQUIRED` (usage, exit 2).
- * Never blocks on a pipe, never silently picks an option.
- */
-export declare function resolveNonInteractive<T>(io: ComponentIO, what: string, defaultValue: T | undefined, alternatives?: string[]): InteractiveResult<T> | null;

package/dist/components/keys.d.ts

@@ -1,48 +0,0 @@
-/**
- * Byte → key decoding for the interactive components (U.7). Pure data
- * transformation — no terminal, no state — so every mapping row is directly
- * unit-testable. The stateful raw-mode plumbing lives in `input.ts`.
- */
-/** One decoded keypress. The full vocabulary the U.7 components consume. */
-export type Key = 
-/** A printable character (UTF-8; may be multi-byte, never a control char). */
-{
-    kind: "char";
-    char: string;
-} | {
-    kind: "enter";
-} | {
-    kind: "backspace";
-} | {
-    kind: "tab";
-} | {
-    kind: "escape";
-} | {
-    kind: "up";
-} | {
-    kind: "down";
-} | {
-    kind: "left";
-} | {
-    kind: "right";
-}
-/** Ctrl-C in raw mode (no SIGINT is delivered) — components must cancel. */
- | {
-    kind: "ctrl-c";
-}
-/** Ctrl-D or stream end — components must cancel. */
- | {
-    kind: "eof";
-};
-/**
- * Decode one raw-mode chunk into keys. A paste or fast typing delivers many
- * keys per chunk; all are returned in order.
- *
- * Escape handling is deliberately simple: `ESC [ A..D` decodes to an arrow,
- * any other CSI sequence (`ESC [ …final`) is swallowed whole (unmapped keys
- * must not leak garbage chars into a query), and a lone ESC decodes to
- * `escape`. Terminals send arrow sequences atomically in practice; a sequence
- * split across chunks degrades to `escape` + literal chars, which is safe
- * (escape cancels).
- */
-export declare function decodeKeys(chunk: Buffer | string): Key[];

package/dist/components/select.d.ts

@@ -1,28 +0,0 @@
-import { type ComponentIO, type InteractiveResult } from "./input.js";
-/**
- * SelectList (U.7): arrow-key pick from a short list of options. Single-select
- * only — multi-select is a deliberate seam for a later build (the result type
- * and key loop extend without breaking callers).
- */
-export interface SelectOptions<T> {
-    /** Label an item renders under. Defaults to `String(item)`. */
-    toLabel?: (item: T) => string;
-    /** Header row above the options. */
-    title?: string;
-    /** Index highlighted first (so Enter-once picks a sensible default). */
-    initialIndex?: number;
-    /** Non-TTY fallback: resolve to this instead of failing loud. */
-    defaultValue?: T;
-    /** `--flag` alternatives listed in the non-TTY error. */
-    nonInteractiveHint?: string[];
-    /** Visible rows before the list scrolls (default 10). */
-    maxVisible?: number;
-}
-/**
- * Pick one item: ↑/↓ move (wrapping past either end), Enter selects the
- * highlighted item, Esc / Ctrl-C / EOF cancel. Renders a transient frame via
- * the shared U.7 frame (width-truncated rows, no soft-wrap) and erases it
- * completely before resolving. Empty `items` resolves cancelled — there is
- * nothing to select.
- */
-export declare function selectList<T>(items: readonly T[], opts?: SelectOptions<T>, io?: ComponentIO): Promise<InteractiveResult<T>>;

package/dist/config/credentials.d.ts

@@ -1,18 +0,0 @@
-/** `~/.cruxy/credentials.json` */
-export declare function credentialsPath(): string;
-/** The stored key for `provider`, or `undefined`. Never throws. */
-export declare function readCredential(provider: string, file?: string): string | undefined;
-/**
- * The stored MCP bearer token for credential name `ref`, or `undefined` (C.27c).
- * Reads ONLY this owner-only store — never the environment, never any config file
- * — so a project config that merely NAMES a credential can never widen where the
- * secret is sourced from. Never throws.
- */
-export declare function readMcpCredential(ref: string, file?: string): string | undefined;
-/** Persist MCP bearer token for credential name `ref`. Same owner-only guarantee. */
-export declare function writeMcpCredential(ref: string, token: string, file?: string): void;
-/**
- * Persist `key` for `provider`, merging into any existing store. Written
- * owner-only (see {@link writeInto}); refuses loudly if that can't be enforced.
- */
-export declare function writeCredential(provider: string, key: string, file?: string): void;

package/dist/config/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./schema.js";
-export * from "./paths.js";
-export * from "./manager.js";
-export * from "./project.js";
-export * from "./credentials.js";

package/dist/config/manager.d.ts

@@ -1,39 +0,0 @@
-import { type CruxyConfig } from "./schema.js";
-export interface LoadOptions {
-    /** Explicit config file, bypassing project discovery. */
-    configPath?: string;
-    /** Start dir for project-config discovery (defaults to cwd). */
-    cwd?: string;
-}
-export interface LoadedConfig {
-    config: CruxyConfig;
-    sources: {
-        global: string | null;
-        project: string | null;
-        explicit: string | null;
-    };
-}
-/**
- * Resolution order (later wins):
- *   schema defaults -> global file -> project file (or explicit) -> env vars
- */
-export declare function loadConfig(opts?: LoadOptions): LoadedConfig;
-/** Resolve a dot-path (e.g. "model.temperature") against a config object. */
-export declare function getPath(obj: unknown, path: string): unknown;
-/**
- * Set a dot-path on the given config file (creating it if needed), validating
- * the full merged result before writing. Returns the written file path.
- */
-export declare function setValue(path: string, rawValue: string, file: string): string;
-/** Write a default config to `file` if it does not already exist. */
-export declare function initConfig(file: string): {
-    path: string;
-    created: boolean;
-};
-/**
- * Provider API key, resolved **env → credentials store → undefined**. The
- * environment always wins (CI / one-off overrides); the credentials store
- * (`~/.cruxy/credentials.json`, written by onboarding / `cruxy login`) is the
- * persistent fallback. The key is never read from `config.json`.
- */
-export declare function resolveApiKey(provider: string): string | undefined;

package/dist/config/owner-only.d.ts

@@ -1,19 +0,0 @@
-/**
- * Make `path` owner-only, or throw. On Windows the ACL is verified after the
- * edit (both the `icacls` exit code AND a read-back), so a returned call is a
- * genuine guarantee, never a best-effort attempt.
- *
- * @throws if owner-only permissions cannot be established (non-zero `icacls`,
- *   an unresolvable SID, a filesystem without ACLs/modes, …).
- */
-export declare function enforceOwnerOnly(path: string, opts?: {
-    directory?: boolean;
-}): void;
-/**
- * Whether `path` is currently owner-only. POSIX: no group/other bits. Windows:
- * best-effort — the ACL names no broad principal (Everyone / Authenticated
- * Users / Users). Used both to verify {@link enforceOwnerOnly} and to warn on a
- * pre-existing store with loose permissions. Returns `true` when it genuinely
- * cannot tell (a missing tool), so a warning path never cries wolf.
- */
-export declare function isOwnerOnly(path: string): boolean;

package/dist/config/paths.d.ts

@@ -1,9 +0,0 @@
-/** ~/.cruxy */
-export declare function globalDir(): string;
-/** ~/.cruxy/config.json */
-export declare function globalConfigPath(): string;
-/**
- * Walk up from `startDir` looking for a project config file. Returns the first
- * match, or null if none is found before the filesystem root.
- */
-export declare function findProjectConfig(startDir?: string): string | null;

package/dist/config/project.d.ts

@@ -1,10 +0,0 @@
-/**
- * Load project instructions from `cwd`: the first of CRUXY.md, then AGENTS.md
- * that exists is read and returned. A missing (or unreadable) file is not an
- * error — it simply yields `null`. Oversized files are truncated to `MAX_BYTES`
- * with a trailing notice so they can't blow up the system prompt.
- *
- * Only `cwd` is consulted (no parent-directory walk) — instructions are scoped
- * to the project you launched cruxy in.
- */
-export declare function loadProjectInstructions(cwd: string): string | null;