@cruxy/cli 1.0.3 → 1.0.4

package/dist/memory/types.d.ts

@@ -1,101 +0,0 @@
-import { z } from "zod";
-/**
- * Types for persistent memory (C.29). Everything here is **data**: a memory
- * entry is validated (fail-loud, malformed excluded) and stored as structured
- * JSON that is NEVER eval'd. Recalled entries are injected into the model's
- * context as clearly-demarcated REFERENCE DATA (see `recall.ts`) — they are not
- * instructions and can never grant authority: the U.3 approval gate is
- * structural and does not read memory at all (proven in `recall.test.ts`).
- */
-/**
- * What a memory entry records. A small, closed set — the enum is the extension
- * point (out of scope: freeform blobs, which we deliberately reject).
- * - `fact` — a durable fact about the user or project.
- * - `decision` — a choice made and its rationale.
- * - `preference` — how the user likes things done.
- */
-export declare const MEMORY_KINDS: readonly ["fact", "decision", "preference"];
-export type MemoryKind = (typeof MEMORY_KINDS)[number];
-/**
- * Where an entry lives. `user` (`~/.cruxy/memory`) is your own memory, authored
- * on this machine → trusted. `project` (`<repo>/.cruxy/memory`) can arrive with
- * a cloned repo (another author) → untrusted until explicitly trusted (see
- * `trust.ts`). This is the supply-chain boundary.
- */
-export declare const MEMORY_SCOPES: readonly ["user", "project"];
-export type MemoryScope = (typeof MEMORY_SCOPES)[number];
-/** Recall renders `user` first (trusted, cross-project), then `project`. */
-export declare const MEMORY_SCOPE_ORDER: readonly MemoryScope[];
-/** Hard cap on a single note's length — memory is for terse facts, not blobs;
- * this also bounds the per-entry cost of the recall budget. */
-export declare const MAX_CONTENT_CHARS = 2000;
-/**
- * Strict schema for one memory entry as persisted. `.strict()` rejects unknown
- * keys so a malformed/foreign object is a loud validation error (excluded), not
- * silently absorbed. Parsed with this on every load — the file is never trusted
- * shape-wise just because it is JSON.
- */
-export declare const MemoryEntrySchema: z.ZodObject<{
-    /** Stable unique id (crypto.randomUUID) — the handle for `forget`. */
-    id: z.ZodString;
-    kind: z.ZodEnum<["fact", "decision", "preference"]>;
-    /** The note. DATA, never instructions. Non-empty, length-capped. */
-    content: z.ZodString;
-    scope: z.ZodEnum<["user", "project"]>;
-    /** ISO 8601 timestamp the entry was recorded. */
-    createdAt: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    kind: "fact" | "decision" | "preference";
-    id: string;
-    createdAt: string;
-    content: string;
-    scope: "project" | "user";
-}, {
-    kind: "fact" | "decision" | "preference";
-    id: string;
-    createdAt: string;
-    content: string;
-    scope: "project" | "user";
-}>;
-export type MemoryEntry = z.infer<typeof MemoryEntrySchema>;
-/** Current on-disk file version — lets a future migration detect old files. */
-export declare const MEMORY_FILE_VERSION = 1;
-/** The whole `entries.json` file shape (one file per scope). */
-export declare const MemoryFileSchema: z.ZodObject<{
-    version: z.ZodDefault<z.ZodNumber>;
-    entries: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
-}, "strict", z.ZodTypeAny, {
-    entries: unknown[];
-    version: number;
-}, {
-    entries?: unknown[] | undefined;
-    version?: number | undefined;
-}>;
-/** Why an entry was rejected on load — surfaced, never silently dropped. */
-export type MemoryLoadReason = "invalid" | "secret";
-/** A rejected entry (malformed, or a detected secret), excluded from recall and
- * from the writable set, and surfaced loudly. */
-export interface MemoryLoadError {
-    scope: MemoryScope;
-    reason: MemoryLoadReason;
-    /** The offending entry's id when known (else a positional marker). */
-    id: string;
-    message: string;
-}
-/** The validated result of loading one scope's file: the good entries plus the
- * excluded ones. A missing file is not an error — it yields an empty result. */
-export interface MemoryLoad {
-    entries: MemoryEntry[];
-    errors: MemoryLoadError[];
-}
-/** One repo's recorded PROJECT-memory trust decision (persisted in
- * `~/.cruxy/memory-trust.json`). The `fingerprint` binds trust to the exact
- * project entries seen at trust time, so editing them re-gates (see `trust.ts`). */
-export interface MemoryTrust {
-    /** Absolute project root. */
-    root: string;
-    /** sha256 of the canonicalized project entries (see `fingerprintMemory`). */
-    fingerprint: string;
-    /** ISO timestamp the decision was recorded. */
-    at: string;
-}

package/dist/net/ip-guard.d.ts

@@ -1,55 +0,0 @@
-/**
- * The ONE owner of "is this IP allowed to be reached" (JC-A). The SSRF address
- * math — parsing and range-classifying v4/v6 literals, including IPv4-mapped and
- * alternate encodings — lives here and nowhere else. Both the web subsystem
- * (`web/ssrf.ts`, C.20) and the network MCP transport (`mcp/http-transport.ts`,
- * C.27b) consume it, so there is exactly one implementation of the range rules
- * and one place to audit them.
- *
- * The two connection-facing helpers a caller needs are also here:
- * - {@link assertAllPublic} — resolve a host and require EVERY address be public;
- * - {@link pinnedLookup} — a `dns.lookup` shim that pins a connection to a set of
- *   already-validated addresses (defeats DNS rebinding). Each subsystem wraps it
- *   in its OWN undici `Agent` (the web one-shot fetch vs. MCP's long-lived
- *   POST + SSE shape differ), but the pinning logic is shared.
- */
-/** Resolve a hostname to its IP addresses (injected so the guard is testable). */
-export type HostResolver = (host: string) => Promise<string[]>;
-/** Default resolver: node's `dns.lookup` returning ALL addresses. */
-export declare const defaultResolveHost: HostResolver;
-/** Thrown when a URL/host is refused pre-dispatch; carries a human reason. */
-export declare class BlockedHostError extends Error {
-}
-/** Thrown when the host could not be resolved (a network failure, not a block). */
-export declare class HostUnresolvedError extends Error {
-}
-/** True if an address (v4 or v6) is in a range that must never be reached. */
-export declare function isBlockedAddress(addr: string): boolean;
-/**
- * True if an address is a LOOPBACK address (127.0.0.0/8, ::1, or an IPv4-mapped
- * loopback). This is the ONLY range the network MCP transport permits over plain
- * `http` (loopback dev servers); everything else must be `https` to a public IP.
- * An unparseable address is not loopback (fail closed — it won't get the http pass).
- */
-export declare function isLoopbackAddress(addr: string): boolean;
-/**
- * Resolve `host` and require that EVERY resolved address is public — the SSRF
- * gate for any URL a caller did not fully control. Throws {@link BlockedHostError}
- * if any address is private/loopback/link-local/reserved (a security refusal), or
- * {@link HostUnresolvedError} if the host cannot be resolved (a network failure).
- * Returns the validated addresses so the caller can PIN the connection to them.
- */
-export declare function assertAllPublic(host: string, resolve: HostResolver): Promise<string[]>;
-/**
- * A `dns.lookup`-compatible function that ignores the hostname and always hands
- * back one of the pre-validated `addresses`. This is what pins a connection to the
- * address the SSRF check already approved, defeating DNS rebinding: the socket can
- * only reach a validated IP, never a value re-resolved at connect time. The Host
- * header / TLS SNI still carry the original hostname (only the dialed IP is pinned).
- */
-export declare function pinnedLookup(addresses: string[]): (_hostname: string, options: unknown, callback: (err: NodeJS.ErrnoException | null, address: string | {
-    address: string;
-    family: number;
-}[], family?: number) => void) => void;
-/** Sort + dedupe an address set so equality checks are order-insensitive. */
-export declare function normalizeAddressSet(addresses: string[]): string[];

package/dist/onboarding/detect.d.ts

@@ -1,26 +0,0 @@
-import type { OnboardingState } from "./types.js";
-/** `~/.cruxy/onboarding.json` */
-export declare function onboardingStatePath(): string;
-/** Read persisted onboarding state, or `null` if absent/unreadable. */
-export declare function readOnboardingState(file?: string): OnboardingState | null;
-/** Persist onboarding state (creates `~/.cruxy` if needed). */
-export declare function writeOnboardingState(state: OnboardingState, file?: string): void;
-/** A fresh state object. */
-export declare function newOnboardingState(): OnboardingState;
-/** Whether onboarding has been completed (the marker exists). */
-export declare function onboardingCompleted(file?: string): boolean;
-export interface FirstRunInput {
-    readonly provider: string;
-    /** Whether stdin is a TTY (the gate — non-TTY is never first-run). */
-    readonly interactive: boolean;
-    /** Override key resolution (tests); defaults to {@link resolveApiKey}. */
-    readonly resolveKey?: (provider: string) => string | undefined;
-    /** Override completion check (tests); defaults to {@link onboardingCompleted}. */
-    readonly completed?: () => boolean;
-}
-/**
- * True iff we should launch the guided first-run flow: interactive **and** no
- * resolvable key **and** no completion marker. Any one being false means we do
- * not onboard (non-TTY fails loud elsewhere; a marker means "don't nag again").
- */
-export declare function isFirstRun(input: FirstRunInput): boolean;

package/dist/onboarding/flow.d.ts

@@ -1,28 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import type { OnboardingDeps, OnboardingOptions, OnboardingResult, ValidationOutcome } from "./types.js";
-/**
- * Orchestrate the onboarding steps (U.6) — resumable and idempotent. The key
- * step is skipped when a key already resolves; the completion marker is written
- * only once a key is in place. An abort during the (mandatory) key step returns
- * `{ aborted: true }` and writes **no** marker, so it resumes next time.
- */
-export declare function runOnboarding(opts: OnboardingOptions): Promise<OnboardingResult>;
-/** Dependencies for the default (production) wiring. */
-export interface DefaultDepsOptions {
-    config: CruxyConfig;
-    cwd: string;
-    /** Runs the first-win task; omit to disable that step. */
-    runTask?: (prompt: string) => Promise<void>;
-}
-/**
- * Build the production {@link OnboardingDeps}: live gateway validation, the
- * credentials store, real state persistence, and a wall-clock timestamp.
- */
-export declare function createDefaultDeps(opts: DefaultDepsOptions): OnboardingDeps;
-/**
- * Validate a key with one cheap live call: start a 1-token stream and look at the
- * first event. `AuthError` ⇒ invalid (bad key), `NetworkError` ⇒ unreachable;
- * anything else (a token, rate-limit, transient API error) means the key was
- * accepted, so ⇒ valid.
- */
-export declare function validateKeyLive(provider: string, apiKey: string, config: CruxyConfig): Promise<ValidationOutcome>;

package/dist/onboarding/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./types.js";
-export * from "./detect.js";
-export * from "./io.js";
-export * from "./steps.js";
-export * from "./flow.js";

package/dist/onboarding/io.d.ts

@@ -1,9 +0,0 @@
-import type { OnboardingIO } from "./types.js";
-/**
- * The real stdin/stderr-backed {@link OnboardingIO}. Prompts go to stderr (stdout
- * stays clean for piping); the secret reader echoes `*` per keystroke and never
- * the real character. Raw-mode key handling is the shared U.7 reader
- * (`components/input.ts`) — the single owner of `setRawMode` — so cooked mode
- * is restored on every exit path, Ctrl-C / EOF included.
- */
-export declare function defaultOnboardingIO(color?: boolean): OnboardingIO;

package/dist/onboarding/steps.d.ts

@@ -1,17 +0,0 @@
-import type { OnboardingDeps, OnboardingIO, StepResult } from "./types.js";
-/**
- * Acquire and persist a provider key: print the create-key URL, read it masked,
- * validate it live, and **only then** write it to the credentials store. Loops on
- * a rejected key (up to 3 tries); a network failure or an empty entry stops.
- */
-export declare function acquireKeyStep(io: OnboardingIO, deps: OnboardingDeps, provider: string): Promise<StepResult>;
-/**
- * Offer to scaffold a project `CRUXY.md`. Skipped silently when one already
- * exists (or `AGENTS.md`); otherwise a `y` confirmation writes the template.
- */
-export declare function scaffoldStep(io: OnboardingIO, cwd: string): Promise<StepResult>;
-/**
- * Offer the first-win demo run. Skipped when no runner is wired or the user
- * declines; otherwise runs one real task so they see value immediately.
- */
-export declare function firstWinStep(io: OnboardingIO, deps: OnboardingDeps): Promise<StepResult>;

package/dist/onboarding/types.d.ts

@@ -1,81 +0,0 @@
-/**
- * Types for the first-run onboarding flow (U.6). The flow is built from injected
- * dependencies (validation, persistence, the first-win runner) so every step is
- * unit-testable with scripted IO and no real network or filesystem.
- */
-/** Outcome of validating a candidate key against the gateway. */
-export type ValidationOutcome = "valid" | "invalid" | "unreachable";
-/** Why a step ended. `aborted` is reserved for the mandatory key step. */
-export type StepStatus = "ok" | "skipped" | "aborted" | "failed";
-export interface StepResult {
-    readonly status: StepStatus;
-    /** The validated key, when a key step succeeds. */
-    readonly apiKey?: string;
-    /** A short human note (e.g. why a step failed) for the caller to surface. */
-    readonly message?: string;
-}
-/** Persisted onboarding state / completion marker (`~/.cruxy/onboarding.json`). */
-export interface OnboardingState {
-    readonly version: number;
-    /** ISO timestamp; **its presence is the completion marker**. */
-    readonly completedAt?: string;
-    /** Whether a key has been successfully configured at least once. */
-    readonly keyConfigured?: boolean;
-}
-export interface OnboardingResult {
-    /** True once the flow ran to completion and wrote the marker. */
-    readonly completed: boolean;
-    /** True when the user aborted (Ctrl-C / EOF) before a key was saved. */
-    readonly aborted: boolean;
-    /** The key in effect after onboarding, if any. */
-    readonly apiKey?: string;
-}
-/**
- * IO surface for onboarding — a superset of the approval `PromptIO` with a
- * **masked** `readSecret()`. Injectable so tests script keystrokes and capture
- * every write (to assert the secret is never echoed).
- */
-export interface OnboardingIO {
-    /** Emit prompt text (to stderr in the default impl). */
-    write(text: string): void;
-    /** Read one line in cooked mode; "" on EOF. */
-    readLine(): Promise<string>;
-    /** Read a single keypress (y/n prompts); "" on EOF / Ctrl-C. */
-    readKey(): Promise<string>;
-    /** Read a secret with no echo (each char shown as `*`); "" on Ctrl-C / EOF. */
-    readSecret(): Promise<string>;
-    /** Whether to emit ANSI color. */
-    color: boolean;
-}
-/** Injected dependencies — the seams for testing and for the default wiring. */
-export interface OnboardingDeps {
-    /** Validate a candidate key with one cheap live call. */
-    validateKey(provider: string, apiKey: string): Promise<ValidationOutcome>;
-    /** Persist a validated key to the credentials store (`0600`). */
-    writeCredential(provider: string, key: string): void;
-    /** Resolve the currently effective key (env → store). */
-    resolveApiKey(provider: string): string | undefined;
-    /** Read persisted onboarding state, or `null`. */
-    readState(): OnboardingState | null;
-    /** Persist onboarding state. */
-    writeState(state: OnboardingState): void;
-    /** Run the first-win task; absent ⇒ the first-win step is skipped. */
-    runTask?: (prompt: string) => Promise<void>;
-    /** Project root (for the scaffold step). */
-    cwd: string;
-    /** ISO timestamp source (injectable for deterministic tests). */
-    now: () => string;
-}
-export type OnboardingMode = "first-run" | "login" | "init";
-export interface OnboardingOptions {
-    readonly provider: string;
-    readonly mode: OnboardingMode;
-    /** Run the key step even if a key already resolves (re-key, `cruxy login`). */
-    readonly forceKey?: boolean;
-    /** Offer the first-win demo run (only when there's no real task queued). */
-    readonly offerFirstWin?: boolean;
-    /** Offer to scaffold a project `CRUXY.md` (init). */
-    readonly offerScaffold?: boolean;
-    readonly io: OnboardingIO;
-    readonly deps: OnboardingDeps;
-}

package/dist/plan/approve.d.ts

@@ -1,16 +0,0 @@
-import type { PromptIO } from "../approval/index.js";
-import type { Plan, PlanDecision } from "./types.js";
-/**
- * The plan-approval prompt (C.31). Renders the plan and reads a single-key,
- * 3-way decision, reusing the U.3 {@link PromptIO} (so it's testable with the
- * same scripted-IO helper and honors NO_COLOR / non-TTY). The copy is explicit
- * that "allow safe steps" never covers destructive or irreversible actions.
- *
- * Default-deny: EOF / Ctrl-C / any unrecognized key → `abort`.
- */
-export declare function promptPlanDecision(plan: Plan, io: PromptIO): Promise<PlanDecision>;
-/**
- * After a failed step, ask whether to continue with the remaining steps or abort
- * the run. Default-deny → abort (the safe choice: stop on failure).
- */
-export declare function promptContinueAfterFailure(io: PromptIO): Promise<boolean>;

package/dist/plan/execute.d.ts

@@ -1,28 +0,0 @@
-import type { PromptIO } from "../approval/index.js";
-import type { StreamRenderer } from "../render/index.js";
-import type { Plan, PlanExecutionResult, PlanStep } from "./types.js";
-/**
- * Execute an approved plan step-by-step (C.31): mark each step `running`, run it,
- * mark `done` / `failed`, rendering live status. Fail-loud — a failed step
- * **halts** by default (no silent skip); the user chooses continue or abort.
- *
- * The per-step runner is injected (`runStep`) so ordering, status, and
- * halt-on-failure are testable without a real model. In production it drives one
- * agent turn scoped to the step, with per-action U.3 gating still applying.
- */
-export interface ExecuteDeps {
-    /**
-     * Run one step. Resolve normally on success; **throw** (ideally a
-     * {@link CruxyError}) to signal failure — that halts the run.
-     */
-    runStep: (step: PlanStep) => Promise<void>;
-    io: PromptIO;
-    /**
-     * Live step progress (U.4): each step feeds `[i/n] title` to the renderer's
-     * progress register, straight from this walk of `plan.steps` — the same
-     * statuses the committed trail renders, never recomputed. Optional so the
-     * executor stays drivable without a terminal (tests, future CI mode).
-     */
-    renderer?: StreamRenderer;
-}
-export declare function executePlan(plan: Plan, deps: ExecuteDeps): Promise<PlanExecutionResult>;

package/dist/plan/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./types.js";
-export * from "./submit-plan.js";
-export * from "./policy.js";
-export * from "./render.js";
-export * from "./approve.js";
-export * from "./execute.js";
-export * from "./service.js";

package/dist/plan/policy.d.ts

@@ -1,26 +0,0 @@
-import type { ApprovalDecision, ApprovalPolicy, ApprovalRequest, SessionAllowlist } from "../approval/index.js";
-/**
- * The execution-phase approval policy for plan mode (C.31). It wraps the base
- * (interactive) policy and adds exactly one behavior, gated behind the user's
- * "approve + allow safe steps" choice: auto-allow **grantable mutate** actions
- * for the rest of the run, recording the real scope in the shared
- * {@link SessionAllowlist} so U.3's own scoping (`scopeCovers`) governs reuse.
- *
- * What it deliberately does NOT do — the two-tier boundary:
- *   • **destructive** actions always fall through to the base policy (prompt);
- *   • **ungrantable** actions (`scope:"none"`) always fall through (prompt),
- *     even if the tier is `mutate` — because `SessionAllowlist.grant` is a no-op
- *     on `none`, an ungrantable action can never be pre-approved.
- *
- * So approving a plan (even with "allow safe steps") never consents to a
- * destructive or irreversible action; those re-confirm at execution time.
- */
-export declare class PlanExecutionPolicy implements ApprovalPolicy {
-    private readonly allowlist;
-    private readonly base;
-    private safeStepGrants;
-    constructor(allowlist: SessionAllowlist, base: ApprovalPolicy);
-    /** Turn on auto-allow for safe (grantable mutate) steps — the `[g]` choice. */
-    enableSafeStepGrants(): void;
-    decide(request: ApprovalRequest): Promise<ApprovalDecision>;
-}

package/dist/plan/render.d.ts

@@ -1,5 +0,0 @@
-import type { Plan, PlanStep } from "./types.js";
-/** Render the whole plan as a block (header + one line per step + rationale). */
-export declare function renderPlan(plan: Plan, color: boolean): string;
-/** A one-line status update for a single step (used during execution). */
-export declare function renderStepStatus(step: PlanStep, color: boolean): string;

package/dist/plan/service.d.ts

@@ -1,58 +0,0 @@
-import type { Message, Provider, Usage } from "@cruxy/sdk";
-import type { CruxyConfig } from "../config/index.js";
-import type { PromptIO } from "../approval/index.js";
-import { ToolRegistry, type ToolContext } from "../tools/index.js";
-import { type AgentResult } from "../agent/loop.js";
-import type { StreamRenderer } from "../render/index.js";
-import type { Router } from "../routing/index.js";
-import { PlanExecutionPolicy } from "./policy.js";
-/**
- * Orchestrates a plan-mode turn (C.31): propose → approve/revise (capped) →
- * execute, all on the ordinary agent loop. The propose phase runs with a
- * read-only + `submit_plan` registry so the agent cannot act before approval;
- * execution runs with the full registry, one step at a time, per-action U.3
- * gating intact.
- */
-/** Default cap on plan revisions before failing loud. */
-export declare const MAX_PLAN_REVISIONS = 3;
-export interface PlanSessionArgs {
-    provider: Provider;
-    config: CruxyConfig;
-    ctx: ToolContext;
-    /** The full (execution-phase) tool registry. */
-    execRegistry: ToolRegistry;
-    /** The plan-mode approval policy (flipped on the `[g]` choice). */
-    planPolicy: PlanExecutionPolicy;
-    /** Prompt IO for plan approval + status (reuses U.3's PromptIO). */
-    io: PromptIO;
-    /** Whether we can actually prompt (a TTY). Non-interactive → fail loud. */
-    interactive: boolean;
-    /** The running conversation (with the user turn already appended). */
-    messages: Message[];
-    git?: {
-        branch: string;
-        dirty: boolean;
-    } | null;
-    projectInstructions?: string | null;
-    /** Persistent memory (C.29): recall block injected into the propose + execute
-     * phases' system prompts (reference data only). */
-    recalledMemory?: string | null;
-    renderer?: StreamRenderer;
-    /** Revision cap (defaults to {@link MAX_PLAN_REVISIONS}). */
-    maxRevisions?: number;
-    /**
-     * Multi-model routing (C.30). When set, the propose phase routes on `plan`
-     * and step execution on `main-turn`; omitted → the provider default.
-     */
-    router?: Router;
-    /**
-     * Usage telemetry (C.22): forwarded to every model request the plan turn
-     * drives (propose + each execution step), so plan-mode usage is captured and
-     * tier-attributed exactly like a normal turn.
-     */
-    onRequestUsage?: (req: {
-        tier?: string;
-        usage?: Usage;
-    }) => void;
-}
-export declare function runPlanSession(args: PlanSessionArgs): Promise<AgentResult>;

package/dist/plan/submit-plan.d.ts

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../tools/index.js";
-import type { PlanHolder } from "./types.js";
-declare const parameters: z.ZodObject<{
-    steps: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        rationale: z.ZodString;
-        kind: z.ZodEnum<["read", "mutate", "destructive"]>;
-    }, "strip", z.ZodTypeAny, {
-        kind: "read" | "mutate" | "destructive";
-        title: string;
-        rationale: string;
-    }, {
-        kind: "read" | "mutate" | "destructive";
-        title: string;
-        rationale: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    steps: {
-        kind: "read" | "mutate" | "destructive";
-        title: string;
-        rationale: string;
-    }[];
-}, {
-    steps: {
-        kind: "read" | "mutate" | "destructive";
-        title: string;
-        rationale: string;
-    }[];
-}>;
-/** Build a `submit_plan` tool bound to `holder`, which captures the last plan. */
-export declare function makeSubmitPlanTool(holder: PlanHolder): Tool<typeof parameters>;
-export {};

package/dist/plan/types.d.ts

@@ -1,60 +0,0 @@
-/**
- * Types for plan mode (C.31). A {@link Plan} is a first-class, typed artifact the
- * agent produces via the `submit_plan` tool — never free text — so the user can
- * review the shape of the work once, and execution can track per-step status.
- */
-/**
- * The agent's risk *estimate* for a step, used only to render intent and shape
- * the approval copy. It is NOT authoritative: the real U.3 gate re-classifies
- * every concrete action at execution time (a step the agent calls "mutate" whose
- * action turns out destructive still confirms).
- */
-export type PlanStepKind = "read" | "mutate" | "destructive";
-/** Live execution status of a step. */
-export type PlanStepStatus = "pending" | "running" | "done" | "failed";
-export interface PlanStep {
-    /** Stable 1-based id assigned on submit (e.g. "1"). */
-    readonly id: string;
-    /** One-line imperative title. */
-    readonly title: string;
-    /** Why this step exists / what it accomplishes. */
-    readonly rationale: string;
-    /** The agent's risk estimate (advisory; see {@link PlanStepKind}). */
-    readonly kind: PlanStepKind;
-    /** Mutated in place as execution progresses. */
-    status: PlanStepStatus;
-}
-export interface Plan {
-    readonly steps: PlanStep[];
-}
-/**
- * The user's decision at the plan-approval prompt.
- * - `approve` — execute; every action still hits the U.3 gate.
- * - `approve-grant` — execute AND auto-allow the safe (read/mutate, grantable)
- *   steps for this run; destructive/ungrantable actions still confirm.
- * - `revise` — send `feedback` back to the agent for a revised plan.
- * - `abort` — cancel; nothing executes (also the default-deny for EOF/Ctrl-C).
- */
-export type PlanDecision = {
-    readonly kind: "approve";
-} | {
-    readonly kind: "approve-grant";
-} | {
-    readonly kind: "revise";
-    readonly feedback: string;
-} | {
-    readonly kind: "abort";
-};
-/** Outcome of executing an approved plan. */
-export interface PlanExecutionResult {
-    /** True if every step reached `done`. */
-    readonly completed: boolean;
-    /** True if a step failed and the user chose to abort the run. */
-    readonly halted: boolean;
-    /** The id of the step that failed, when halted. */
-    readonly failedStepId?: string;
-}
-/** A mutable holder the `submit_plan` tool writes the captured plan into. */
-export interface PlanHolder {
-    plan: Plan | null;
-}

package/dist/render/capabilities.d.ts

@@ -1,31 +0,0 @@
-import type { RenderCapabilities, RenderStream } from "./types.js";
-/** Fallback width when the terminal reports none (non-TTY, pipe, unknown). */
-export declare const DEFAULT_COLUMNS = 80;
-/**
- * Resolve the terminal width (U.12) — the single rule behind
- * {@link RenderCapabilities.width} and every resize recompute. `COLUMNS` wins
- * when set (honored so `COLUMNS=100 cruxy …` and CI overrides work), then the
- * stream's own `columns`, then {@link DEFAULT_COLUMNS}. Never returns a
- * non-positive width — an unknown terminal degrades to a sensible default, it
- * does not crash a width calculation with 0.
- */
-export declare function resolveColumns(stream?: RenderStream, env?: NodeJS.ProcessEnv): number;
-/**
- * Reduced-motion (U.11) — the ecosystem `NO_MOTION` signal, the explicit cruxy
- * knob `CRUXY_REDUCED_MOTION`, and `CRUXY_NO_SPINNER` kept as an alias flowing
- * through this one axis. A screen reader implies it (no live region to animate).
- * The single source of the spinner gate.
- */
-export declare function detectReducedMotion(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Probe the environment once and reduce it to {@link RenderCapabilities}. Pure
- * given its inputs (stream + env are injectable), so every row of the
- * degradation matrix is directly testable.
- *
- * Color reuses {@link shouldUseColor} (NO_COLOR / FORCE_COLOR / TTY) with one
- * refinement: `TERM=dumb` terminals get no color even though they are TTYs.
- * The axes are independent (U.1/U.11): a NO_COLOR terminal still supports
- * in-place status updates; a dumb terminal supports neither; reduced motion and
- * screen-reader mode compose orthogonally with color and unicode.
- */
-export declare function detectCapabilities(stream?: RenderStream, env?: NodeJS.ProcessEnv): RenderCapabilities;

package/dist/render/diff.d.ts

@@ -1,18 +0,0 @@
-import type { ActionPreview } from "../tools/types.js";
-import type { Theme } from "../theme/index.js";
-/**
- * The one diff/action-preview renderer (U.2). The approval prompt, PR preview,
- * and the streaming render path all draw diffs through here — there is no
- * second implementation to drift. Pure data → string; color is sourced from
- * the resolved {@link Theme} (U.1), so NO_COLOR/non-TTY callers get symbol-only
- * `+`/`-` lines from the exact same code path. Diff add/remove intentionally
- * reuse the `success`/`danger` hues (green/red), as before.
- */
-/** Cap on rendered preview lines before collapsing the rest. */
-export declare const PREVIEW_MAX_LINES = 40;
-/**
- * Render any {@link ActionPreview} as an indented block: a diff for edits and
- * patches, a create/overwrite listing for writes, the publish plan for PRs.
- * Long previews collapse past {@link PREVIEW_MAX_LINES}.
- */
-export declare function renderActionPreview(preview: ActionPreview | undefined, c: Theme, width?: number): string;