agent-afk 5.1.0 → 5.3.0

package/dist/cli/commands/doctor-checks.d.ts

@@ -0,0 +1,19 @@
+import { type DetectedSource, type ImportFromConfig } from '../../config/import-sources.js';
+export interface Check {
+    name: string;
+    state: 'pass' | 'warn' | 'fail';
+    detail?: string;
+    fix?: string;
+}
+export declare function checkAnthropicKey(): Promise<Check>;
+export declare function checkCodexKey(): Promise<Check>;
+export declare function checkNpmBinOnPath(): Promise<Check>;
+export declare function checkDirWritable(name: string, getDir: () => string): Promise<Check>;
+export declare function checkConfigFile(): Promise<Check>;
+export declare function checkRequiredEnvVars(): Promise<Check | null>;
+export declare function checkTelegram(): Promise<Check | null>;
+export declare function checkImportAvailable(deps?: {
+    detected?: DetectedSource[];
+    trusted?: ImportFromConfig;
+}): Promise<Check | null>;
+export declare function runDoctorChecks(): Promise<Check[]>;

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

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

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

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { createFarm, setFarmMemoryFactId } from '../../agent/worktree.js';
+import { runSubagentDAG } from '../../agent/dag-subagent.js';
+import { scoreBranch, writeScore } from '../../skills/score/index.js';
+import { writeFarmFact } from '../../skills/score/memory-write.js';
+import { sendFarmDigest } from '../../skills/score/digest.js';
+import { createDefaultTraceWriter } from '../../agent/trace/factory.js';
+declare function getCommitCount(worktreePath: string, baseSha: string): Promise<number>;
+declare function getSourceRepoDirtyFiles(sourceCwd: string): Promise<string[]>;
+export declare class FarmIsolationViolation extends Error {
+    readonly dirtyFiles: string[];
+    constructor(dirtyFiles: string[]);
+}
+export interface RunFarmOptions {
+    task: string;
+    branches: number;
+    labels?: string[];
+    model?: string;
+    baseRef?: string;
+    cwd?: string;
+    failFast: boolean;
+    taskSlug?: string;
+    score?: boolean;
+    scoreTimeoutMs?: number;
+    memoryWrite?: boolean;
+    digest?: boolean;
+    _createFarm?: typeof createFarm;
+    _runSubagentDAG?: typeof runSubagentDAG;
+    _getCommitCount?: typeof getCommitCount;
+    _getSourceRepoDirtyFiles?: typeof getSourceRepoDirtyFiles;
+    _scoreBranch?: typeof scoreBranch;
+    _writeScore?: typeof writeScore;
+    _writeFarmFact?: typeof writeFarmFact;
+    _sendFarmDigest?: typeof sendFarmDigest;
+    _setFarmMemoryFactId?: typeof setFarmMemoryFactId;
+    _createTraceWriter?: typeof createDefaultTraceWriter;
+}
+export declare function runFarm(opts: RunFarmOptions): Promise<void>;
+export declare function registerFarmCommand(program: Command): void;
+export {};

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

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

package/dist/cli/commands/interactive/afk-push.d.ts

@@ -0,0 +1,14 @@
+import { pushIfConfigured } from '../../../telegram/push.js';
+import type { ToolEvent } from '../../slash/types.js';
+import type { TerminalState } from './terminal-state.js';
+export declare const MAX_PUSHES_PER_SESSION = 20;
+export declare const DONE_EVIDENCE_TOOLS: ReadonlySet<string>;
+export declare function doneHasCorroboratingEvidence(toolEvents: readonly ToolEvent[]): boolean;
+export declare function formatTerminalStateForTelegram(state: TerminalState, opts?: {
+    unverified?: boolean;
+}): string;
+export declare function resetAfkPushBudget(): void;
+export declare function afkPushCount(): number;
+export declare function pushTerminalStateToTelegram(state: TerminalState, pushImpl?: typeof pushIfConfigured, opts?: {
+    unverified?: boolean;
+}): Promise<void>;

package/dist/cli/commands/interactive/at-file-inject.d.ts

@@ -0,0 +1,17 @@
+export declare const AT_FILE_MAX_SIZE_BYTES: number;
+export declare const AT_FILE_TOTAL_MAX_BYTES: number;
+export interface AtFileBlock {
+    type: 'text';
+    text: string;
+}
+export interface AtFileInjectResult {
+    fileBlocks: AtFileBlock[];
+    warnings: string[];
+}
+export interface AtFileInjectOpts {
+    rootDir?: string;
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function detectAtFileInject(env?: NodeJS.ProcessEnv): boolean;
+export declare function expandAtFileTokens(text: string, opts?: AtFileInjectOpts): AtFileInjectResult;

package/dist/cli/commands/interactive/boot-prune.d.ts

@@ -0,0 +1,8 @@
+export interface BootPruneResult {
+    ran: boolean;
+    removedCount: number;
+    skippedReason?: 'not-in-repo' | 'lock-contested' | 'timeout' | 'error' | 'disabled';
+}
+export declare function bootPruneWorktrees(opts?: {
+    disabled?: boolean;
+}): Promise<BootPruneResult>;

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

@@ -0,0 +1,30 @@
+import { AgentSession } from '../../../agent/session.js';
+import type { PermissionMode } from '../../../agent/types/sdk-types.js';
+import type { ThinkingConfig, EffortLevel } from '../../../agent/types.js';
+import type { AgentConfig } from '../../../agent/types.js';
+import type { ModelProvider } from '../../../agent/provider.js';
+import type { HookRegistry } from '../../../agent/hooks.js';
+import type { TraceWriter } from '../../../agent/trace/index.js';
+import type { CliOptions, InteractiveCtx } from './shared.js';
+interface BuildAgentSessionDeps {
+    model: string;
+    resumeConfig: Partial<AgentConfig>;
+    systemPrompt: string | undefined;
+    systemPromptSource: string | undefined;
+    thinking: ThinkingConfig | undefined;
+    effort: EffortLevel | undefined;
+    maxOutputTokens: number | undefined;
+    providerFactory: (model: string | undefined) => ModelProvider;
+    hookRegistry: HookRegistry;
+    traceWriter: TraceWriter | undefined;
+    cwd: string | undefined;
+    maxTurns: number;
+    autoResumeOnUsageLimit: boolean | undefined;
+    permissionMode?: PermissionMode;
+    baseUrl?: string;
+}
+export declare function buildAgentSession(deps: BuildAgentSessionDeps): AgentSession;
+export declare function bootstrapSession(options: CliOptions, extras?: {
+    cwd?: string;
+}): Promise<InteractiveCtx>;
+export {};

package/dist/cli/commands/interactive/context-pane.d.ts

@@ -0,0 +1,11 @@
+import { loadTodos } from '../../todo-panel.js';
+export interface ContextPane {
+    renderIfChanged(sessionId: string | undefined): string[];
+    invalidate(): void;
+    dispose(): void;
+}
+export interface ContextPaneOptions {
+    load?: (sessionId: string) => ReturnType<typeof loadTodos>;
+    onResize?: (cb: () => void) => () => void;
+}
+export declare function createContextPane(opts?: ContextPaneOptions): ContextPane;

package/dist/cli/commands/interactive/footer-subsystems.d.ts

@@ -0,0 +1,15 @@
+import type { InteractiveCtx } from './shared.js';
+import { createContextPane } from './context-pane.js';
+import { createVerdictLedger } from './verdict-ledger.js';
+import { BackgroundStatusBar } from '../../background-status-bar.js';
+import { LoopStageBar } from './loop-stage.js';
+import { ShellPassthrough } from './shell-passthrough.js';
+import type { TurnState } from './repl-loop-shared.js';
+export interface FooterSubsystems {
+    contextPane: ReturnType<typeof createContextPane>;
+    bgStatusBar: BackgroundStatusBar;
+    loopStageBar: LoopStageBar;
+    verdictLedger: ReturnType<typeof createVerdictLedger>;
+    shellPassthrough: ShellPassthrough;
+}
+export declare function setupFooterSubsystems(ctx: InteractiveCtx, turnState: TurnState): FooterSubsystems;

package/dist/cli/commands/interactive/loop-iteration.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveCtx } from './shared.js';
+import type { TranscriptHandle } from './transcript.js';
+import type { InputSurface } from '../../input/input-surface.js';
+import type { ReplHistory } from '../../input/history.js';
+import { type TurnState } from './repl-loop-shared.js';
+import type { FooterSubsystems } from './footer-subsystems.js';
+export declare function runInputLoop(ctx: InteractiveCtx, transcript: TranscriptHandle, turnState: TurnState, sigintHandler: () => void, surface: InputSurface, installSoftStop: (handler: (() => void) | null) => void, footer: FooterSubsystems, history: ReplHistory): Promise<void>;

package/dist/cli/commands/interactive/loop-stage.d.ts

@@ -0,0 +1,34 @@
+import type { OutputEvent } from '../../../agent/types.js';
+export type LoopStage = 'observing' | 'modeling' | 'choosing' | 'acting' | 'updating';
+export declare const LOOP_STAGES: readonly LoopStage[];
+export declare const STAGE_LABEL: Record<LoopStage, string>;
+export interface StageTrackerState {
+    stage: LoopStage;
+    pendingTools: Set<string>;
+}
+export declare function createStageTracker(): StageTrackerState;
+export declare function resetStageTracker(s: StageTrackerState): void;
+export declare function advanceStage(s: StageTrackerState, event: OutputEvent): boolean;
+export declare function formatStageRail(active: LoopStage, fmt: {
+    dim: (s: string) => string;
+    accent: (s: string) => string;
+    bold: (s: string) => string;
+}): string;
+export declare class LoopStageBar {
+    private readonly stream;
+    private readonly getExtraRows;
+    private started;
+    private currentStage;
+    private resizeUnsub;
+    private onRowCountChange?;
+    constructor(opts: {
+        getExtraRows: () => number;
+        stream?: NodeJS.WriteStream;
+    });
+    setRowCountChangeHandler(handler: (rows: number) => void): void;
+    start(): void;
+    stop(): void;
+    repaint(stage: LoopStage): void;
+    redraw(): void;
+    private clearRow;
+}

package/dist/cli/commands/interactive/progress-banner.d.ts

@@ -0,0 +1,5 @@
+import type { SubagentCompleteInfo } from '../../../agent/default-hook-registry.js';
+import type { ProgressEvent } from '../../../agent/types.js';
+export declare function formatProgressBanner(event: ProgressEvent, columns?: number): string[];
+export declare function formatProgressSummary(event: ProgressEvent, columns?: number): string;
+export declare function formatSubagentCompletion(info: SubagentCompleteInfo, columns?: number): string;

package/dist/cli/commands/interactive/provider-factory.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProvider } from '../../../agent/provider.js';
+export declare function createMemoizedProviderFactory(buildProvider: (model: string | undefined) => ModelProvider, keyForModel: (model: string | undefined) => string): (model: string | undefined) => ModelProvider;

package/dist/cli/commands/interactive/repl-loop-shared.d.ts

@@ -0,0 +1,10 @@
+import type { PermissionMode } from '../../../agent/types/sdk-types.js';
+export interface TurnState {
+    turnInFlight: boolean;
+    lastSigintAt: number;
+    activeCompositor?: import('../../terminal-compositor.js').TerminalCompositor | null;
+    tryAbortShellForeground?: (() => boolean) | null;
+    notifyInterrupting?: ((active: boolean) => void) | null;
+    requestSoftStop?: (() => void) | null;
+}
+export declare function buildPrompt(mode: PermissionMode): string;

package/dist/cli/commands/interactive/repl-loop.d.ts

@@ -0,0 +1,6 @@
+import type { InteractiveCtx } from './shared.js';
+import type { TranscriptHandle } from './transcript.js';
+import type { TurnState } from './repl-loop-shared.js';
+export type { TurnState };
+export declare function resolveSuggestGhost(envRaw: string | undefined, jsonVal: boolean | undefined): boolean;
+export declare function runReplLoop(ctx: InteractiveCtx, transcript: TranscriptHandle, turnState: TurnState, sigintHandler: () => void): Promise<void>;

package/dist/cli/commands/interactive/repl-renderer.d.ts

@@ -0,0 +1,16 @@
+interface CompositorRef {
+    isArmed(): boolean;
+    commitAbove(text: string): void;
+}
+export interface ScrollRegionGuard {
+    withFullScrollRegion<T>(fn: () => T): T;
+}
+export interface ReplRenderer {
+    writeLine(text: string): void;
+    setCompositor(c: CompositorRef | null): void;
+}
+export interface CreateReplRendererOpts {
+    statusLine?: ScrollRegionGuard;
+}
+export declare function createReplRenderer(stdout: NodeJS.WriteStream, opts?: CreateReplRendererOpts): ReplRenderer;
+export {};

package/dist/cli/commands/interactive/resume-swap.d.ts

@@ -0,0 +1,23 @@
+import { resumeConfigFor, type ResolvedResumeTarget } from '../../resume-session.js';
+import { type ResumeSwapResult, type CompletionWriter } from './shared.js';
+import type { SessionRef } from '../../../agent/session-ref.js';
+import type { SessionStats } from '../../slash/types.js';
+import type { ContextSampler } from '../../context-sampler.js';
+import type { GitStatusSampler } from '../../git-status-sampler.js';
+import type { StatusLine } from '../../status-line.js';
+import type { BackgroundAgentRegistry } from '../../../agent/background-registry.js';
+import type { AgentSession } from '../../../agent/session.js';
+export interface ResumeSwapDeps {
+    sessionRef: SessionRef;
+    stats: SessionStats;
+    contextSampler: ContextSampler;
+    gitStatusSampler?: GitStatusSampler;
+    statusLine: StatusLine;
+    backgroundRegistry: BackgroundAgentRegistry;
+    completionWriter: CompletionWriter;
+    isInFlight: () => boolean;
+    onSwapped: (target: ResolvedResumeTarget) => void;
+    buildSession: (target: ResolvedResumeTarget) => AgentSession;
+}
+export declare function performResumeSwap(target: ResolvedResumeTarget, deps: ResumeSwapDeps): Promise<ResumeSwapResult>;
+export { resumeConfigFor };

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

@@ -0,0 +1,116 @@
+import * as readline from 'node:readline';
+import type { HookRegistry } from '../../../agent/hooks.js';
+import type { SessionRef } from '../../../agent/session-ref.js';
+import type { MemoryStore } from '../../../agent/memory/index.js';
+import type { AgentModelInput } from '../../../agent/types.js';
+import type { BackgroundAgentRegistry } from '../../../agent/background-registry.js';
+import type { BackgroundSummarizer } from '../../../agent/background-summarizer.js';
+import type { SubagentControl } from '../../../agent/tools/subagent-executor.js';
+import type { SlashContext, SessionStats, ResumeSwapResult } from '../../slash/types.js';
+import type { StoredSession } from '../../session-store.js';
+import type { StatusLine } from '../../status-line.js';
+import type { ReplRenderer } from './repl-renderer.js';
+import type { ResolvedResumeTarget } from '../../resume-session.js';
+import { ContextSampler } from '../../context-sampler.js';
+import type { GitStatusSampler } from '../../git-status-sampler.js';
+export type { ResumeSwapResult } from '../../slash/types.js';
+export declare function reseedStatsFromStored(stats: SessionStats, stored: StoredSession, resumeId: string): void;
+export declare function printResumeBanner(stats: SessionStats, writer: CompletionWriter): void;
+export type ThinkingUiMode = 'summary' | 'live' | 'off';
+export interface CliOptions {
+    model: AgentModelInput;
+    maxTurns: string;
+    thinking?: string;
+    thinkingUi: ThinkingUiMode;
+    effort?: string;
+    maxOutputTokens?: string;
+    resume?: string;
+    continue?: boolean;
+    debug?: boolean;
+    dangerouslySkipPermissions?: boolean;
+    worktree?: string | true;
+    worktreeAutoname?: boolean;
+    worktreeBase?: string;
+    shellPassthrough?: boolean;
+    provider?: string;
+    dumpPrompt?: string | boolean;
+    mcpConfig?: string;
+}
+export interface InteractiveCtx {
+    session: SessionRef;
+    memoryStore: MemoryStore;
+    stats: SessionStats;
+    statusLine: StatusLine;
+    contextSampler: ContextSampler;
+    gitStatusSampler: GitStatusSampler;
+    completionWriter: CompletionWriter;
+    replRenderer: ReplRenderer;
+    slashCtx: SlashContext;
+    rl: readline.Interface;
+    options: CliOptions;
+    resumeTarget?: ResolvedResumeTarget;
+    teardownTrustedSkillEvents?: () => void;
+    mcpManager?: import('../../../agent/mcp/index.js').McpManager;
+    backgroundRegistry: BackgroundAgentRegistry;
+    subagentControl?: SubagentControl;
+    bgSummarizer?: BackgroundSummarizer;
+    firstTurnHook?: (firstMessage: string) => Promise<void>;
+    getInFlight?: () => boolean;
+    requestResume?: (target: ResolvedResumeTarget) => Promise<ResumeSwapResult>;
+    clearVerdictLedger?: () => void;
+    preArmAnchorRow?: number;
+    inputSurfaceRef?: {
+        current: import('../../input/input-surface.js').InputSurface | null;
+    };
+    suggestApiKey?: string;
+    suggestBaseUrl?: string;
+    suggestGhostConfig?: boolean;
+    hookRegistry?: HookRegistry;
+}
+export interface CompletionWriter {
+    fn: (line: string) => void;
+    idleFn: (line: string) => void;
+}
+export interface TurnHandles {
+    setInFlight(v: boolean): void;
+    onUserMessage?(userInput: string): Promise<void> | void;
+    onTurnComplete?(userInput: string, assistantText: string): Promise<void>;
+    onAfterTurn?(): void | Promise<void>;
+    rearmStatus?(): void;
+    onTerminalState?(state: import('./terminal-state.js').TerminalState): void;
+    setActiveCompositor?(c: import('../../terminal-compositor.js').TerminalCompositor | null): void;
+    setInterruptNotifier?(notifier: ((active: boolean) => void) | null): void;
+    scrollRegion?: {
+        withFullScrollRegion<T>(fn: () => T): T;
+        getExtraRows(): number;
+    };
+    getCompositor?(): import('../../terminal-compositor.js').TerminalCompositor | null;
+    setBackgroundHandler?(handler: (() => void) | null): void;
+    subagentControl?: SubagentControl;
+    setSoftStopHandler?(handler: (() => void) | null): void;
+    setPausedState?(paused: boolean): void;
+    setPauseInterruptHandler?(handler: (() => void) | null): void;
+    onContextProgress?(): void | Promise<void>;
+    onStageChange?(stage: import('./loop-stage.js').LoopStage): void;
+}
+export declare const REPL_SPINNER_OPTIONS: {
+    readonly stream: NodeJS.WriteStream & {
+        fd: 1;
+    };
+    readonly hideCursor: false;
+    readonly discardStdin: false;
+};
+export declare function contextRatio(stats: SessionStats, sampler?: ContextSampler): number;
+export declare function formatStatusFields(stats: SessionStats, sampler?: ContextSampler, gitSampler?: GitStatusSampler): {
+    pr?: number | undefined;
+    branch?: string | undefined;
+    cwd?: string | undefined;
+    model: string;
+    cost: number;
+    tokens: number;
+    contextPct: number;
+    contextLimit: number;
+    contextUsedTokens: number | undefined;
+    contextSparkline: string | undefined;
+    permissionMode: import("../../../agent/types.js").PermissionMode;
+};

package/dist/cli/commands/interactive/shell-passthrough.d.ts

@@ -0,0 +1,33 @@
+import { ShellJobRegistry, type ShellJob, type ShellResult, type ShellErrorReason } from '../../../agent/shell-jobs/index.js';
+export interface ShellPassthroughOptions {
+    writeLine: (text: string) => void;
+    getCwd: () => string | undefined;
+}
+export declare function parseShellTrigger(input: string): {
+    mode: 'foreground' | 'background';
+    command: string;
+} | null;
+export interface PendingBgNotification {
+    job: ShellJob;
+    result: ShellResult;
+}
+export declare class ShellPassthrough {
+    private readonly opts;
+    readonly registry: ShellJobRegistry;
+    private pendingInjections;
+    private pendingNotifications;
+    private activeFgJobId;
+    static readonly MAX_PENDING_INJECTIONS = 25;
+    static readonly MAX_PENDING_NOTIFICATIONS = 50;
+    constructor(opts: ShellPassthroughOptions);
+    dispatch(input: string): Promise<boolean>;
+    drainInjections(): string;
+    drainNotifications(): readonly PendingBgNotification[];
+    abortActiveForeground(): boolean;
+    hasActiveForeground(): boolean;
+    drainOnExit(): void;
+    private runForeground;
+    private startBackground;
+    private queueInjection;
+}
+export type { ShellJob, ShellResult, ShellErrorReason };

package/dist/cli/commands/interactive/surface-setup.d.ts

@@ -0,0 +1,12 @@
+import type { InputSurface } from '../../input/input-surface.js';
+import type { InteractiveCtx } from './shared.js';
+import type { TranscriptHandle } from './transcript.js';
+import type { LoopStageBar } from './loop-stage.js';
+import { type TurnState } from './repl-loop-shared.js';
+export interface SurfaceSetupDeps {
+    getLoopStageBar: () => LoopStageBar | undefined;
+}
+export interface SurfaceSetupResult {
+    installSoftStop: (handler: (() => void) | null) => void;
+}
+export declare function setupSurface(ctx: InteractiveCtx, surface: InputSurface, turnState: TurnState, transcript: TranscriptHandle, sigintHandler: () => void, suggestGhostEnabled: boolean, deps: SurfaceSetupDeps): Promise<SurfaceSetupResult>;

package/dist/cli/commands/interactive/terminal-state.d.ts

@@ -0,0 +1,18 @@
+export type TerminalKind = 'done' | 'blocked' | 'asking' | 'interrupted';
+export interface TerminalState {
+    kind: TerminalKind;
+    whatWasDone?: string;
+    evidence?: string;
+    deferred?: string;
+    whatBlocks?: string;
+    unblockCondition?: string;
+    alreadyDone?: string;
+    question?: string;
+    assumption?: string;
+    followup?: string;
+    whatWasInProgress?: string;
+    stateLocation?: string;
+    resumeRequires?: string;
+    rawBody: string;
+}
+export declare function parseTerminalState(text: string): TerminalState | null;

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

@@ -0,0 +1,18 @@
+export declare function formatThoughtSummary(durationMs: number, charCount: number): string;
+export declare class ThinkingLane {
+    private buffer;
+    private startedAt;
+    private endedAt;
+    private hasEmitted;
+    private committedUpTo;
+    push(chunk: string): void;
+    markEnded(): void;
+    isActive(): boolean;
+    hasBufferedContent(): boolean;
+    peek(): string;
+    consume(): string;
+    peekPhase(): string;
+    drainPhase(): string;
+    collapse(): string | null;
+    inlineSummary(): string | null;
+}

package/dist/cli/commands/interactive/thinking-paragraph.d.ts

@@ -0,0 +1,5 @@
+export interface ThinkingParagraphOptions {
+    cols: number;
+    maxLines?: number;
+}
+export declare function formatThinkingParagraph(buffer: string, opts: ThinkingParagraphOptions): string;

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

@@ -0,0 +1,4 @@
+export declare function shortenPaths(text: string): string;
+export declare function summarizeToolArgs(name: string, args: string): string;
+export declare function bracketPairAwareTruncate(args: string, maxWidth: number, ellipsis?: string): string;
+export declare function formatToolLine(content: string, maxWidth?: number): string;

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

@@ -0,0 +1,4 @@
+import type { DiffPayload } from '../../../utils/diff.js';
+export declare const MAX_OVERLAY_DIFF_LINES = 8;
+export declare const FLUSH_DIFF_LINES_DEFAULT = 30;
+export declare function formatDiffBlock(diff: DiffPayload, mode: 'overlay' | 'flush', indent: string): string[];

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

@@ -0,0 +1,2 @@
+export declare function sanitizeLabel(raw: string): string;
+export declare function sanitizeTextParagraph(raw: string): string;

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

@@ -0,0 +1,14 @@
+import type { ToolResultChunk } from '../../../agent/types/message-types.js';
+import { sanitizeLabel, sanitizeTextParagraph } from './tool-lane-format-sanitize.js';
+export { sanitizeLabel, sanitizeTextParagraph };
+export { shortenPaths, summarizeToolArgs, bracketPairAwareTruncate, formatToolLine, } from './tool-lane-format-args.js';
+export { MAX_OVERLAY_DIFF_LINES, FLUSH_DIFF_LINES_DEFAULT, formatDiffBlock, } from './tool-lane-format-diff.js';
+export declare const DONE_GLYPH: string;
+export declare const ERROR_GLYPH: string;
+export declare function doneGlyph(isError: boolean | undefined): string;
+export declare const MAX_VISIBLE_CHILDREN = 3;
+export declare const GROUP_THRESHOLD_DISPATCH = 2;
+export declare const GROUP_THRESHOLD_LEAF = 3;
+export declare function inProgressVerb(toolName: string): string;
+export declare function formatOutcome(chunk: ToolResultChunk, homeDir?: string, maxPreview?: number, toolName?: string): string;
+export declare function formatToolResultLine(chunk: ToolResultChunk, toolPrefix?: string, homeDir?: string, toolName?: string): string;

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

@@ -0,0 +1,7 @@
+import type { ToolEntry, Entry } from './tool-lane-render.js';
+declare function formatAgentSummary(agent: ToolEntry, children: Entry[], childMap: Map<string, Entry[]>, homeDir?: string, ancestorIsLast?: readonly boolean[]): string;
+declare function formatAgentHeader(agent: ToolEntry, ancestorIsLast?: readonly boolean[]): string;
+declare function formatAgentChildren(agent: ToolEntry, children: Entry[], childMap: Map<string, Entry[]>, homeDir?: string, ancestorIsLast?: readonly boolean[]): string[];
+declare function renderGroupedRootTools(groups: Map<string, ToolEntry[]>, groupOrder: string[], homeDir?: string): string[];
+declare function formatGroupedToolResults(toolName: string, entries: ToolEntry[], homeDir?: string): string;
+export { formatAgentSummary, formatAgentHeader, formatAgentChildren, renderGroupedRootTools, formatGroupedToolResults, };

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

@@ -0,0 +1,4 @@
+import type { Entry, Glyphs } from './tool-lane-render.js';
+declare function renderOverlayChildren(children: Entry[], childMap: Map<string, Entry[]>, lines: string[], cols?: number, ancestorIsLast?: readonly boolean[], g?: Readonly<Glyphs>, parentIsLast?: boolean): void;
+declare function renderFlushChildren(children: Entry[], childMap: Map<string, Entry[]>, homeDir?: string, agentResultSummary?: string, cols?: number, ancestorIsLast?: readonly boolean[], g?: Readonly<Glyphs>, parentIsLast?: boolean): string[];
+export { renderOverlayChildren, renderFlushChildren };

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

@@ -0,0 +1,15 @@
+import type { ToolEntry } from './tool-lane-render.js';
+interface GroupedSibling {
+    kind: 'group';
+    toolName: string;
+    label: string;
+    entries: ToolEntry[];
+}
+export interface OverflowSibling {
+    kind: 'overflow';
+    count: number;
+    text: string;
+}
+export declare function addOverflowSynthetic(siblings: Array<ToolEntry | GroupedSibling>, maxVisible: number): Array<ToolEntry | GroupedSibling | OverflowSibling>;
+export declare function formatCategoricalOverflow(hidden: Array<ToolEntry | GroupedSibling>): string;
+export {};

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

@@ -0,0 +1,23 @@
+import type { ToolEntry } from './tool-lane-render.js';
+import type { Glyphs } from './tool-lane-render.js';
+import { addOverflowSynthetic, formatCategoricalOverflow, type OverflowSibling } from './tool-lane-render-grouping-overflow.js';
+interface GroupedSibling {
+    kind: 'group';
+    toolName: string;
+    label: string;
+    entries: ToolEntry[];
+}
+interface ResultSummarySibling {
+    kind: 'resultSummary';
+    summary: string;
+}
+type RenderableSibling = ToolEntry | GroupedSibling | OverflowSibling | ResultSummarySibling;
+interface ConnectedSibling {
+    sibling: RenderableSibling;
+    connector: string;
+}
+declare function assignConnectors(siblings: RenderableSibling[], g?: Readonly<Glyphs>): ConnectedSibling[];
+declare function addResultSummarySynthetic(siblings: RenderableSibling[], agentResultSummary: string | undefined): RenderableSibling[];
+declare function groupSiblings(toolChildren: ToolEntry[]): Array<ToolEntry | GroupedSibling>;
+declare function formatGroupedSibling(group: GroupedSibling): string;
+export { assignConnectors, addOverflowSynthetic, addResultSummarySynthetic, groupSiblings, formatGroupedSibling, formatCategoricalOverflow, type GroupedSibling, type OverflowSibling, type ResultSummarySibling, type RenderableSibling, type ConnectedSibling, };

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

@@ -0,0 +1,45 @@
+import type { ToolResultChunk } from '../../../agent/types/message-types.js';
+import type { DiffPayload } from '../../../utils/diff.js';
+export declare function clampLineToTerminal(line: string, cols: number): string;
+interface ToolEntryFields {
+    toolUseId: string;
+    toolName: string;
+    toolInput: string;
+    prefix: string;
+    result?: ToolResultChunk;
+    agentContext?: string;
+    agentResultSummary?: string;
+    thinkingTail?: string;
+    diff?: DiffPayload;
+    headerEmitted?: boolean;
+}
+export type ToolEntry = ToolEntryFields & {
+    kind: 'tool';
+};
+export interface TextEntry {
+    kind: 'text';
+    toolUseId: string;
+    text: string;
+    agentContext: string;
+}
+export type Entry = ToolEntry | TextEntry;
+export interface Glyphs {
+    spine: string;
+    spineClosed: string;
+    lead: string;
+    turnRoot: string;
+    midConnector: string;
+    lastConnector: string;
+    textPrefix: string;
+}
+export declare const UNICODE_GLYPHS: Readonly<Glyphs>;
+export declare const ASCII_GLYPHS: Readonly<Glyphs>;
+export declare const TREE_CONNECTOR_MID: string;
+export declare const TREE_CONNECTOR_LAST: string;
+export declare function getGlyphs(): Readonly<Glyphs>;
+export declare function buildIndent(ancestorIsLast: readonly boolean[], g: Readonly<Glyphs>): string;
+export declare function colorizeIndent(plainIndent: string, g: Readonly<Glyphs>): string;
+export declare function renderTextChildLines(text: string, indent: string, g: Readonly<Glyphs>): string[];
+export { assignConnectors, addOverflowSynthetic, addResultSummarySynthetic, type GroupedSibling, type OverflowSibling, type ResultSummarySibling, type RenderableSibling, type ConnectedSibling, } from './tool-lane-render-grouping.js';
+export { renderOverlayChildren, renderFlushChildren } from './tool-lane-render-children.js';
+export { formatAgentSummary, formatAgentHeader, formatAgentChildren, renderGroupedRootTools, formatGroupedToolResults, } from './tool-lane-render-agent.js';