agent-afk 5.1.0 → 5.2.0

package/dist/cli/commands/interactive/tool-lane.d.ts

@@ -0,0 +1,31 @@
+import type { ToolResultChunk } from '../../../agent/types/message-types.js';
+import { formatToolLine, formatToolResultLine } from './tool-lane-format.js';
+import type { DiffPayload } from '../../../utils/diff.js';
+import { type ToolEntry, type TextEntry, type Entry } from './tool-lane-render.js';
+export type { ToolEntry, TextEntry, Entry };
+export declare const MAX_OVERLAY_ROOTS = 6;
+export declare class ToolLane {
+    private entries;
+    private order;
+    private agentIdStack;
+    addStart(toolUseId: string, toolName: string, toolInput: string): void;
+    addStartWithAgentContext(toolUseId: string, toolName: string, toolInput: string, agentContext: string | undefined, maxWidth?: number): void;
+    mergeAgentLabel(parentToolUseId: string, label: string, maxWidth?: number): boolean;
+    setAgentContext(toolUseId: string, agentContext: string | undefined): void;
+    setAgentResultSummary(toolUseId: string, summary: string): void;
+    setThinkingTail(toolUseId: string, tail: string | undefined): void;
+    addResult(toolUseId: string, chunk: ToolResultChunk): void;
+    addDiff(toolUseId: string, diff: DiffPayload): void;
+    upsertTextChild(toolUseId: string, agentContext: string, text: string): void;
+    removeTextChildrenUnder(agentContext: string): void;
+    hasPending(): boolean;
+    hasEntry(id: string): boolean;
+    findLastSkillEntryId(): string | undefined;
+    getOverlay(): string;
+    private ancestorDepthOf;
+    flushSource(parentId: string, homeDir?: string): string[];
+    flushCompletedRoots(homeDir?: string): string[];
+    flush(homeDir?: string): string[];
+    private buildChildMap;
+}
+export { formatToolLine, formatToolResultLine };

package/dist/cli/commands/interactive/transcript.d.ts

@@ -0,0 +1,9 @@
+export declare function startTranscript(dir: string, model: string, continued?: boolean): Promise<string>;
+export interface TranscriptHandle {
+    path(): string;
+    appendUser(userInput: string): Promise<void>;
+    appendTurn(userInput: string, assistantText: string): Promise<void>;
+    rotateOnClear(): Promise<void>;
+    appendEnded(): Promise<void>;
+}
+export declare function initTranscript(getModel: () => string): Promise<TranscriptHandle>;

package/dist/cli/commands/interactive/turn-handler.d.ts

@@ -0,0 +1,16 @@
+import type { AgentSession } from '../../../agent/session.js';
+import type { SessionStats } from '../../slash/types.js';
+import type { ImageAttachment } from '../../input/attachments.js';
+import type { InputSurfaceRefs } from '../../input/input-surface.js';
+import { type CompletionWriter, type ThinkingUiMode, type TurnHandles } from './shared.js';
+export { formatToolLine, formatToolResultLine, ToolLane } from './tool-lane.js';
+export type { InputSurfaceRefs } from '../../input/input-surface.js';
+export declare function runTurn(input: {
+    text: string;
+    attachments: ImageAttachment[];
+}, session: AgentSession, stats: SessionStats, h: TurnHandles, thinkingUi?: ThinkingUiMode, completionWriter?: CompletionWriter, inputSurface?: InputSurfaceRefs): Promise<void>;
+export declare function printTurnFooter(meta: {
+    durationMs?: number;
+    totalCostUsd?: number;
+    usage?: Record<string, unknown>;
+} | undefined, stats: SessionStats, write?: (line: string) => void): void;

package/dist/cli/commands/interactive/verdict-card.d.ts

@@ -0,0 +1,3 @@
+import type { TerminalState } from './terminal-state.js';
+export declare function renderVerdictCard(state: TerminalState): string;
+export declare function summarizeVerdict(state: TerminalState, maxWidth: number): string;

package/dist/cli/commands/interactive/verdict-ledger.d.ts

@@ -0,0 +1,19 @@
+import type { TerminalKind, TerminalState } from './terminal-state.js';
+export interface VerdictLedger {
+    push(state: TerminalState): void;
+    reset(): void;
+    render(): string | null;
+    entries(): readonly TerminalKind[];
+    setRowCountChangeHandler(handler: (rows: number) => void): void;
+    start(opts: VerdictLedgerStartOpts): void;
+    stop(): void;
+    repaint(): void;
+}
+export interface VerdictLedgerStartOpts {
+    stream?: NodeJS.WriteStream;
+    getAdjacentRows?: () => number;
+}
+export interface VerdictLedgerOptions {
+    capacity?: number;
+}
+export declare function createVerdictLedger(opts?: VerdictLedgerOptions): VerdictLedger;

package/dist/cli/commands/interactive/worktree-autoname.d.ts

@@ -0,0 +1,42 @@
+import { type DeferredWorktree } from './worktree.js';
+import type { AgentSession } from '../../../agent/session/agent-session.js';
+export type SkipReason = 'empty-message' | 'slash-command' | 'slug-generator-error' | 'invalid-slug-output';
+export interface AutonameOptions {
+    token: string;
+    model?: string;
+    timeoutMs?: number;
+    worktreePath: string;
+    signal?: AbortSignal;
+    slugGenerator?: (message: string, signal: AbortSignal) => Promise<string>;
+    onSkip?: (reason: SkipReason, detail?: string) => void;
+}
+export declare function generateSlugFromPrompt(message: string, opts: AutonameOptions): Promise<string | null>;
+export declare function sanitizeSlug(raw: string): string | null;
+export type AutonameOutcome = {
+    status: 'created';
+    path: string;
+    branch: string;
+    slug: string;
+} | {
+    status: 'created-fallback';
+    path: string;
+    branch: string;
+    reason: SkipReason | 'create-failed' | 'unknown';
+    detail?: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+export interface RunAutonameInput {
+    deferred: DeferredWorktree;
+    message: string;
+    token: string;
+    model?: string;
+    timeoutMs?: number;
+    session?: AgentSession | null;
+    branchPrefix?: string;
+    slugGenerator?: (message: string, signal: AbortSignal) => Promise<string>;
+    signal?: AbortSignal;
+}
+export declare function runFirstTurnAutoname(input: RunAutonameInput): Promise<AutonameOutcome>;
+export declare function pinProcessCwd(newPath: string): void;

package/dist/cli/commands/interactive/worktree.d.ts

@@ -0,0 +1,33 @@
+export type ExecFileFn = (file: string, args: string[], opts?: {
+    cwd?: string;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export interface WorktreeHandle {
+    path: string;
+    branch: string;
+    cleanup: (opts?: {
+        force?: boolean;
+    }) => Promise<void>;
+}
+export declare const DEFAULT_BRANCH_PREFIX = "afk/";
+export declare function validateBranchPrefix(value: string, source: string): string;
+export declare function resolveBranchPrefix(override?: string): string;
+export declare function setupWorktree(flagValue: string | true, opts?: {
+    execFile?: ExecFileFn;
+    branchPrefix?: string;
+    baseRef?: string;
+}): Promise<WorktreeHandle>;
+export interface DeferredWorktree {
+    repoRoot: string;
+    handle(): WorktreeHandle | undefined;
+    create(flagValue: string | true): Promise<WorktreeHandle>;
+}
+export declare function setupWorktreeDeferred(opts?: {
+    execFile?: ExecFileFn;
+    branchPrefix?: string;
+    baseRef?: string;
+}): Promise<DeferredWorktree>;
+export declare function validateBaseRef(value: string, source: string): void;
+export declare function resolveBaseRef(override?: string): string | undefined;

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

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { type SkipReason } from './interactive/worktree-autoname.js';
+import { type CliConfig } from '../config.js';
+import type { CliOptions } from './interactive/shared.js';
+import { type UpdateInfo } from '../update-checker.js';
+export { formatToolResultLine } from './interactive/tool-lane.js';
+export declare function setInteractiveUpdateNotices(updateInfo: UpdateInfo | null, pendingMessage: string | null): void;
+export declare function formatAutonameSkipReason(reason: SkipReason | 'create-failed' | 'unknown', detail: string | undefined): string | undefined;
+export declare function isAutonameEnabled(options: CliOptions, config: CliConfig): boolean;
+export declare function startupHintLine(): string;
+export declare function registerInteractiveCommand(program: Command): void;

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

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { promptToken } from '../auth-wizard.js';
+export { upsertEnvVar } from '../auth-wizard.js';
+export { promptToken };
+export declare function registerLoginCommand(program: Command): void;

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

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+import { type MarketplaceInstallDeps } from '../../agent/marketplaces/install.js';
+import { type InstallFromMarketplaceDeps } from '../../agent/marketplaces/resolve.js';
+import { type UpdateMarketplaceDeps } from '../../agent/marketplaces/update.js';
+export interface MarketplaceCommandDeps extends MarketplaceInstallDeps, InstallFromMarketplaceDeps, UpdateMarketplaceDeps {
+    logger?: Pick<Console, 'log' | 'error'>;
+}
+export declare function registerMarketplaceCommand(program: Command, deps?: MarketplaceCommandDeps): void;

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

@@ -0,0 +1,14 @@
+import type { Command } from 'commander';
+import { type DetectedSource, type ImportSourceBinary } from '../../config/import-sources.js';
+export declare function registerMigrateCommand(program: Command): void;
+export declare function normalizeBinary(value: string | undefined): ImportSourceBinary | null;
+export declare function buildImportBlock(targets: DetectedSource[], includeMcp: boolean): Record<ImportSourceBinary, {
+    plugins: boolean;
+    skills: boolean;
+    mcp: boolean;
+}>;
+export declare function writeImportFrom(configPath: string, importBlock: Record<string, {
+    plugins: boolean;
+    skills: boolean;
+    mcp: boolean;
+}>): void;

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

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+import { type InstallDeps } from '../../agent/plugins/install.js';
+import { type UpdateDeps } from '../../agent/plugins/update.js';
+export interface PluginCommandDeps extends InstallDeps, UpdateDeps {
+    logger?: Pick<Console, 'log' | 'error'>;
+}
+export declare function registerPluginCommand(program: Command, deps?: PluginCommandDeps): void;

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

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import { type OpenAIAuthSource, type AuthResolverDeps } from '../../agent/providers/openai-compatible/auth.js';
+export declare function buildProviderAuthDiagnose(explicitConfigKey: string | undefined, deps?: AuthResolverDeps): {
+    source: OpenAIAuthSource;
+    message: string;
+    exitCode: number;
+    last4?: string;
+};
+export declare function registerProviderCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerQueueCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerScheduleCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerServiceCommand(program: Command): void;

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

@@ -0,0 +1,6 @@
+import type { Command } from 'commander';
+type SupportedShell = 'bash' | 'zsh' | 'fish';
+export declare function renderShellInit(shell: SupportedShell, markerPath: string): string;
+export declare function detectShellFromEnv(shellEnv: string | undefined): SupportedShell;
+export declare function registerShellInitCommand(program: Command): void;
+export {};

package/dist/cli/commands/skill-router.d.ts

@@ -0,0 +1,9 @@
+import type { IAgentSession } from '../../agent/types.js';
+import '../../skills/mint/index.js';
+import '../../skills/diagnose/index.js';
+export interface RouteResult {
+    handled: true;
+    output: string;
+    status: 'ok' | 'error' | 'help';
+}
+export declare function tryRouteSkill(input: string, session: IAgentSession): Promise<RouteResult | null>;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerStatusCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTelegramCommand(program: Command): void;

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

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import type { TraceEvent } from '../../agent/trace/index.js';
+export interface TraceDirEntry {
+    sessionId: string;
+    tracePath: string;
+    mtimeMs: number;
+    exists: boolean;
+}
+export declare function listTraces(): Promise<TraceDirEntry[]>;
+export declare function resolveLatestSession(): Promise<string | null>;
+export interface ParsedTrace {
+    events: TraceEvent[];
+    malformed: number;
+}
+export declare function parseTrace(content: string): ParsedTrace;
+export declare function loadTrace(session: string): Promise<{
+    sessionId: string;
+    tracePath: string;
+} & ParsedTrace>;
+export interface FormatTraceOptions {
+    showAll?: boolean;
+    limit?: number;
+}
+export declare function formatTrace(sessionId: string, tracePath: string, parsed: ParsedTrace, options?: FormatTraceOptions): string;
+export declare function registerTraceCommand(program: Command): void;

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

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare const MAX_SEARCH_LIMIT = 1000;
+export declare function normalizeLimit(raw: string, fallback?: number): number;
+export declare function registerTranscriptCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerUpdateCommand(program: Command): void;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerWorktreeCommand(program: Command): void;

package/dist/cli/commit-mode.d.ts

@@ -0,0 +1,25 @@
+export interface CommitModeInput {
+    prevTopRow: number;
+    frameTop: number;
+    anchorFloor: number;
+    anchorRow: number;
+    lineCount: number;
+    textLines: string[];
+    rows: number;
+    extraRows: number;
+    committedBand: string[];
+    committedBandBottomRow: number;
+    committedBandPaintedRows: number;
+}
+export interface CommitMode {
+    fitsAboveFrame: boolean;
+    room: number;
+    overflowTargetBottom: number;
+    maxBandModel: number;
+    overflowPriorContiguous: boolean;
+    overflowRun: string[];
+    overflowHasPending: boolean;
+    useBandHold: boolean;
+}
+export declare function decideCommitMode(input: CommitModeInput): CommitMode;
+export declare function capBandModel(run: string[], max: number): string[];

package/dist/cli/config.d.ts

@@ -0,0 +1,69 @@
+import { getModelId, isValidModel } from '../agent/session/model-resolution.js';
+import { type ModelSlots } from '../agent/session/model-slots.js';
+import { type BundledProviderName } from '../agent/providers/index.js';
+import type { AgentModelInput } from '../agent/types.js';
+import type { PermissionMode } from '../agent/types/sdk-types.js';
+import type { RawHooksConfig } from '../agent/hooks/config-loader.js';
+import { type ImportFromConfig, type ImportSourceBinary } from '../config/import-sources.js';
+export type { ImportFromConfig, ImportSourceBinary };
+export { getModelId, isValidModel };
+export interface AutoRoutingConfig {
+    interactive?: boolean;
+    chat?: boolean;
+    telegram?: boolean;
+    daemon?: boolean;
+}
+export interface CliConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model: AgentModelInput;
+    models?: ModelSlots;
+    maxTokens: number;
+    temperature: number;
+    openaiBaseUrl?: string;
+    systemPrompt?: string;
+    systemPromptSource?: string;
+    permissionMode?: PermissionMode;
+    autoRouting?: AutoRoutingConfig;
+    daemon?: {
+        task?: string;
+        taskId?: string;
+        worktreePrune?: {
+            enabled: boolean;
+            cron: string;
+            maxAgeDaysClean: number;
+            maxAgeDaysDirty: number;
+            scope: string;
+        };
+    };
+    telegram?: {
+        notify?: {
+            mode?: 'primary' | 'broadcast' | 'custom';
+            primaryChatId?: number;
+            targets?: number[];
+        };
+        verifyDone?: boolean;
+    };
+    interactive?: {
+        worktreeAutoname?: boolean;
+        worktreeBranchPrefix?: string;
+        worktreeBase?: string;
+        suggestGhost?: boolean;
+    };
+    updatePolicy: 'notify' | 'auto' | 'off';
+    autoResumeOnUsageLimit?: boolean;
+    bgSummaries?: boolean;
+    maxSummaryCallsPerSession?: number;
+    hooks?: RawHooksConfig;
+    enableShellHooks?: boolean;
+    importFrom?: ImportFromConfig;
+}
+export declare const DEFAULT_CLI_PERMISSION_MODE: PermissionMode;
+export declare function loadCredential(): string | undefined;
+export declare function normalizeOpenAIBaseUrl(raw: string): string;
+export declare function _resetOpenAIBaseUrlWarnCache(): void;
+export declare function _resetConfigCache(): void;
+export declare function loadTelegramConfig(): NonNullable<CliConfig['telegram']>;
+export declare function resolveCliPermissionMode(): PermissionMode;
+export declare function loadConfig(overrides?: Partial<CliConfig>): CliConfig;
+export declare function resolvedProviderName(config: CliConfig): BundledProviderName;

package/dist/cli/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SPINNER_VERBS: string[];
+export declare const COMPLETION_VERBS: Record<string, string>;
+export declare function pickRandomVerb(): string;
+export declare function getCompletionVerb(verb: string): string;

package/dist/cli/context-bar.d.ts

@@ -0,0 +1,8 @@
+export interface ContextBarOpts {
+    ratio: number;
+    used?: number;
+    limit?: number;
+    sparkline?: string;
+    width: number;
+}
+export declare function formatContextBar(opts: ContextBarOpts): string;

package/dist/cli/context-sampler.d.ts

@@ -0,0 +1,43 @@
+import type { AgentSession } from '../agent/session.js';
+export interface ContextSamplerOptions {
+    sampleEveryNTurns?: number;
+}
+interface ContextUsageSource {
+    getContextUsage(): Promise<{
+        apiUsage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens: number;
+            cache_read_input_tokens: number;
+        } | null;
+        percentage?: number;
+        totalTokens?: number;
+        maxTokens?: number;
+        autoCompactThreshold?: number;
+        isAutoCompactEnabled: boolean;
+        [key: string]: unknown;
+    }>;
+}
+export declare class ContextSampler {
+    private source;
+    private readonly sampleEveryNTurns;
+    private cachedRatio;
+    private cachedDetail;
+    private inFlight;
+    private disposed;
+    private generation;
+    constructor(source: ContextUsageSource, opts?: ContextSamplerOptions);
+    attach(session: AgentSession): this;
+    getRatio(): number | undefined;
+    getDetail(): {
+        used: number;
+        limit: number;
+        percentage: number;
+    } | undefined;
+    refresh(): Promise<void>;
+    onTurn(turnIndex: number): Promise<void>;
+    reset(): void;
+    dispose(): void;
+    private doFetch;
+}
+export {};

package/dist/cli/context-sparkline.d.ts

@@ -0,0 +1 @@
+export declare function formatTurnSparkline(ratios: number[], n?: number): string;

package/dist/cli/cup-frame-renderer.d.ts

@@ -0,0 +1,18 @@
+import type { Writable } from 'node:stream';
+export declare class CupFrameRenderer {
+    private readonly stream;
+    private previousTopRow;
+    private previousLineCount;
+    private previousRawLineCount;
+    constructor(stream: NodeJS.WriteStream & Writable);
+    get topRow(): number;
+    private static wrapToPhysicalLines;
+    measure(content: string, targetBottomRow: number): {
+        topRow: number;
+        lineCount: number;
+    };
+    render(content: string, targetBottomRow: number, anchorFloor?: number): void;
+    resetGeometry(): void;
+    clear(extraRows?: number): void;
+    done(): void;
+}

package/dist/cli/daemon-options.d.ts

@@ -0,0 +1,11 @@
+import type { TriggerMode } from '../agent/daemon/triggers.js';
+export declare function resolveDaemonTimeoutMs(flagValue: string | undefined, envValue: string | undefined): number | undefined;
+export declare function resolveSessionStartCooldownMs(flagValue: string | undefined, envValue: string | undefined): number | undefined;
+export declare function resolveTriggerMode(flagValue: string | undefined, cronFlag?: string | undefined): TriggerMode;
+export declare const COMPILED_DEFAULT_TASK = "";
+export declare const COMPILED_DEFAULT_TASK_ID = "default";
+export declare function resolveDefaultTask(flagValue: string | undefined, envValue: string | undefined, configValue: string | undefined): string;
+export declare function resolveDefaultTaskId(flagValue: string | undefined, envValue: string | undefined, configValue: string | undefined): string;
+export declare const DEFAULT_DAEMON_HOST = "127.0.0.1";
+export declare function resolveDaemonHost(flagValue: string | undefined, envValue: string | undefined): string;
+export declare function isLoopbackHost(host: string): boolean;

package/dist/cli/debug-banner.d.ts

@@ -0,0 +1,2 @@
+import type { SessionMetadata } from '../agent/types/session-types.js';
+export declare function renderDebugBanner(meta: SessionMetadata): string;

package/dist/cli/display.d.ts

@@ -0,0 +1,19 @@
+export declare function stripAnsi(text: string): string;
+export declare function displayWidth(text: string): number;
+export declare function splitGraphemes(text: string): string[];
+export declare function padDisplayRight(text: string, width: number): string;
+export declare function padDisplayLeft(text: string, width: number): string;
+export declare function padDisplay(text: string, width: number, align?: 'left' | 'right' | 'center'): string;
+export declare function truncateDisplayWidth(text: string, maxWidth: number, ellipsis?: string): string;
+export declare function previousGraphemeIndex(text: string, index: number): number;
+export declare function nextGraphemeIndex(text: string, index: number): number;
+export interface CursorMetrics {
+    row: number;
+    col: number;
+}
+export interface BufferMetrics {
+    cursor: CursorMetrics;
+    end: CursorMetrics;
+    rowsUsed: number;
+}
+export declare function measureBuffer(buffer: string, cursor: number, promptWidth: number, columns: number): BufferMetrics;

package/dist/cli/elicitation-repl.d.ts

@@ -0,0 +1,26 @@
+import type { ElicitationRequest, ElicitationResult } from '../agent/types/sdk-types.js';
+export interface ReplElicitationDeps {
+    readLine: (prompt: string) => Promise<string>;
+    writer: {
+        line: (text?: string) => void;
+    };
+    pendingCount: () => number;
+    suspendInput?: () => void;
+    resumeInput?: () => void;
+    pickFromList?: (opts: {
+        header: readonly string[];
+        options: readonly string[];
+        multi?: boolean;
+        signal: AbortSignal;
+    }) => Promise<readonly string[] | null>;
+    readTextOverlay?: (opts: {
+        header: readonly string[];
+        initial?: string;
+        help?: string;
+        validate?: (value: string) => string | null;
+        signal: AbortSignal;
+    }) => Promise<string | null>;
+}
+export declare function makeReplElicitationHandler(deps: ReplElicitationDeps): (request: ElicitationRequest, options: {
+    signal: AbortSignal;
+}) => Promise<ElicitationResult>;

package/dist/cli/errors/classifier.d.ts

@@ -0,0 +1,9 @@
+export type ErrorKind = 'auth' | 'rate_limit' | 'overloaded' | 'budget_exceeded' | 'unsupported_config' | 'hook_blocked' | 'timeout' | 'network' | 'not_git_repo' | 'unknown';
+export interface ClassifiedError {
+    kind: ErrorKind;
+    userMessage: string;
+    hint?: string;
+    exitCode: number;
+    raw: unknown;
+}
+export declare function classifyError(err: unknown): ClassifiedError;

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

@@ -0,0 +1,4 @@
+export declare function handleCommandError(err: unknown): never;
+export { classifyError } from './classifier.js';
+export { presentError } from './presenter.js';
+export type { ClassifiedError, ErrorKind } from './classifier.js';

package/dist/cli/errors/presenter.d.ts

@@ -0,0 +1,5 @@
+import type { ClassifiedError } from './classifier.js';
+export declare function presentError(classified: ClassifiedError, opts?: {
+    isTTY?: boolean;
+    write?: (s: string) => void;
+}): void;

package/dist/cli/format-cwd.d.ts

@@ -0,0 +1,5 @@
+export interface FormatCwdOptions {
+    homedir?: string;
+    maxWidth?: number;
+}
+export declare function formatCwd(cwd: string, opts?: FormatCwdOptions): string;

package/dist/cli/format-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function formatDuration(ms: number): string;
+export declare function formatCost(usd: number): string;
+export declare function formatTokens(count: number): string;
+export declare function formatFileSize(bytes: number): string;

package/dist/cli/formatter.d.ts

@@ -0,0 +1,27 @@
+interface RenderMarkdownOptions {
+    maxWidth?: number;
+}
+export declare function renderCardLine(text: string): string;
+export declare function renderMarkdownToTerminal(text: string, opts?: RenderMarkdownOptions): string;
+export declare class OutputFormatter {
+    private useColors;
+    constructor(useColors?: boolean);
+    formatMarkdown(text: string): string;
+    formatError(message: string, error?: Error): string;
+    formatSuccess(message: string): string;
+    formatInfo(message: string): string;
+    formatWarning(message: string): string;
+    formatCommand(command: string): string;
+    formatPrompt(modelName: string): string;
+    formatModelInfo(model: string, maxTokens: number, temp: number): string;
+    separator(char?: string, width?: number): string;
+    formatHelp(sections: {
+        title: string;
+        items: string[];
+    }[]): string;
+    formatStreaming(text: string): string;
+}
+export declare const formatter: OutputFormatter;
+export declare function truncate(text: string, maxLength: number): string;
+export declare function wordWrap(text: string, width: number): string;
+export {};