@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/session-selector.d.ts

@@ -0,0 +1,95 @@
+import { type Component, Container, type Focusable } from "@earendil-works/pi-tui";
+import { KeybindingsManager } from "../../../core/keybindings.ts";
+import type { SessionInfo, SessionListProgress } from "../../../core/session-manager.ts";
+import { type NameFilter, type SortMode } from "./session-selector-search.ts";
+/**
+ * Custom session list component with multi-line items and search
+ */
+declare class SessionList implements Component, Focusable {
+    getSelectedSessionPath(): string | undefined;
+    private allSessions;
+    private filteredSessions;
+    private selectedIndex;
+    private searchInput;
+    private showCwd;
+    private sortMode;
+    private nameFilter;
+    private keybindings;
+    private showPath;
+    private confirmingDeletePath;
+    private currentSessionCanonicalPath?;
+    onSelect?: (sessionPath: string) => void;
+    onCancel?: () => void;
+    onExit: () => void;
+    onToggleScope?: () => void;
+    onToggleSort?: () => void;
+    onToggleNameFilter?: () => void;
+    onTogglePath?: (showPath: boolean) => void;
+    onDeleteConfirmationChange?: (path: string | null) => void;
+    onDeleteSession?: (sessionPath: string) => Promise<void>;
+    onRenameSession?: (sessionPath: string) => void;
+    onError?: (message: string) => void;
+    private maxVisible;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(sessions: SessionInfo[], showCwd: boolean, sortMode: SortMode, nameFilter: NameFilter, keybindings: KeybindingsManager, currentSessionFilePath?: string);
+    setSortMode(sortMode: SortMode): void;
+    setNameFilter(nameFilter: NameFilter): void;
+    setSessions(sessions: SessionInfo[], showCwd: boolean): void;
+    private filterSessions;
+    private setConfirmingDeletePath;
+    private startDeleteConfirmationForSelectedSession;
+    private isCurrentSessionPath;
+    invalidate(): void;
+    render(width: number): string[];
+    private buildTreePrefix;
+    handleInput(keyData: string): void;
+}
+type SessionsLoader = (onProgress?: SessionListProgress) => Promise<SessionInfo[]>;
+/**
+ * Component that renders a session selector
+ */
+export declare class SessionSelectorComponent extends Container implements Focusable {
+    handleInput(data: string): void;
+    private canRename;
+    private sessionList;
+    private header;
+    private keybindings;
+    private scope;
+    private sortMode;
+    private nameFilter;
+    private currentSessions;
+    private allSessions;
+    private currentSessionsLoader;
+    private allSessionsLoader;
+    private requestRender;
+    private renameSession?;
+    private currentLoading;
+    private allLoading;
+    private allLoadSeq;
+    private mode;
+    private renameInput;
+    private renameTargetPath;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    private buildBaseLayout;
+    constructor(currentSessionsLoader: SessionsLoader, allSessionsLoader: SessionsLoader, onSelect: (sessionPath: string) => void, onCancel: () => void, onExit: () => void, requestRender: () => void, options?: {
+        renameSession?: (sessionPath: string, currentName: string | undefined) => Promise<void>;
+        showRenameHint?: boolean;
+        keybindings?: KeybindingsManager;
+    }, currentSessionFilePath?: string);
+    private loadCurrentSessions;
+    private enterRenameMode;
+    private exitRenameMode;
+    private confirmRename;
+    private loadScope;
+    private toggleSortMode;
+    private toggleNameFilter;
+    private refreshSessionsAfterMutation;
+    private toggleScope;
+    getSessionList(): SessionList;
+}
+export {};
+//# sourceMappingURL=session-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/settings-selector.d.ts

@@ -0,0 +1,77 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Transport } from "@earendil-works/pi-ai";
+import { Container, SettingsList } from "@earendil-works/pi-tui";
+import type { DefaultProjectTrust, WarningSettings } from "../../../core/settings-manager.ts";
+import { type TerminalTheme } from "../theme/theme.ts";
+export interface SettingsConfig {
+    autoCompact: boolean;
+    showImages: boolean;
+    imageWidthCells: number;
+    autoResizeImages: boolean;
+    blockImages: boolean;
+    enableSkillCommands: boolean;
+    steeringMode: "all" | "one-at-a-time";
+    followUpMode: "all" | "one-at-a-time";
+    transport: Transport;
+    httpIdleTimeoutMs: number;
+    thinkingLevel: ThinkingLevel;
+    availableThinkingLevels: ThinkingLevel[];
+    currentTheme: string;
+    terminalTheme: TerminalTheme;
+    availableThemes: string[];
+    hideThinkingBlock: boolean;
+    showCacheMissNotices: boolean;
+    collapseChangelog: boolean;
+    enableInstallTelemetry: boolean;
+    doubleEscapeAction: "fork" | "tree" | "none";
+    treeFilterMode: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+    showHardwareCursor: boolean;
+    editorPaddingX: number;
+    outputPad: 0 | 1;
+    autocompleteMaxVisible: number;
+    quietStartup: boolean;
+    defaultProjectTrust: DefaultProjectTrust;
+    clearOnShrink: boolean;
+    showTerminalProgress: boolean;
+    warnings: WarningSettings;
+}
+export interface SettingsCallbacks {
+    onAutoCompactChange: (enabled: boolean) => void;
+    onShowImagesChange: (enabled: boolean) => void;
+    onImageWidthCellsChange: (width: number) => void;
+    onAutoResizeImagesChange: (enabled: boolean) => void;
+    onBlockImagesChange: (blocked: boolean) => void;
+    onEnableSkillCommandsChange: (enabled: boolean) => void;
+    onSteeringModeChange: (mode: "all" | "one-at-a-time") => void;
+    onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
+    onTransportChange: (transport: Transport) => void;
+    onHttpIdleTimeoutMsChange: (timeoutMs: number) => void;
+    onThinkingLevelChange: (level: ThinkingLevel) => void;
+    onThemeChange: (theme: string) => void;
+    onThemePreview?: (theme: string) => void;
+    onHideThinkingBlockChange: (hidden: boolean) => void;
+    onShowCacheMissNoticesChange: (shown: boolean) => void;
+    onCollapseChangelogChange: (collapsed: boolean) => void;
+    onEnableInstallTelemetryChange: (enabled: boolean) => void;
+    onDoubleEscapeActionChange: (action: "fork" | "tree" | "none") => void;
+    onTreeFilterModeChange: (mode: "default" | "no-tools" | "user-only" | "labeled-only" | "all") => void;
+    onShowHardwareCursorChange: (enabled: boolean) => void;
+    onEditorPaddingXChange: (padding: number) => void;
+    onOutputPadChange: (padding: 0 | 1) => void;
+    onAutocompleteMaxVisibleChange: (maxVisible: number) => void;
+    onQuietStartupChange: (enabled: boolean) => void;
+    onDefaultProjectTrustChange: (defaultProjectTrust: DefaultProjectTrust) => void;
+    onClearOnShrinkChange: (enabled: boolean) => void;
+    onShowTerminalProgressChange: (enabled: boolean) => void;
+    onWarningsChange: (warnings: WarningSettings) => void;
+    onCancel: () => void;
+}
+/**
+ * Main settings selector component.
+ */
+export declare class SettingsSelectorComponent extends Container {
+    private settingsList;
+    constructor(config: SettingsConfig, callbacks: SettingsCallbacks);
+    getSettingsList(): SettingsList;
+}
+//# sourceMappingURL=settings-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/show-images-selector.d.ts

@@ -0,0 +1,10 @@
+import { Container, SelectList } from "@earendil-works/pi-tui";
+/**
+ * Component that renders a show images selector with borders
+ */
+export declare class ShowImagesSelectorComponent extends Container {
+    private selectList;
+    constructor(currentValue: boolean, onSelect: (show: boolean) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+}
+//# sourceMappingURL=show-images-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/skill-invocation-message.d.ts

@@ -0,0 +1,17 @@
+import { Box, type MarkdownTheme } from "@earendil-works/pi-tui";
+import type { ParsedSkillBlock } from "../../../core/agent-session.ts";
+/**
+ * Component that renders a skill invocation message with collapsed/expanded state.
+ * Uses same background color as custom messages for visual consistency.
+ * Only renders the skill block itself - user message is rendered separately.
+ */
+export declare class SkillInvocationMessageComponent extends Box {
+    private expanded;
+    private skillBlock;
+    private markdownTheme;
+    constructor(skillBlock: ParsedSkillBlock, markdownTheme?: MarkdownTheme);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    private updateDisplay;
+}
+//# sourceMappingURL=skill-invocation-message.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/status-indicator.d.ts

@@ -0,0 +1,28 @@
+import { type Component, Loader, type TUI } from "@earendil-works/pi-tui";
+import type { WorkingIndicatorOptions } from "../../../core/extensions/index.ts";
+export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary";
+export declare class StatusIndicator extends Loader {
+    readonly kind: StatusIndicatorKind;
+    constructor(kind: StatusIndicatorKind, ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message: string, indicator?: WorkingIndicatorOptions);
+    dispose(): void;
+}
+export declare class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, message: string, indicator?: WorkingIndicatorOptions);
+}
+export declare class RetryStatusIndicator extends StatusIndicator {
+    private countdown;
+    constructor(ui: TUI, attempt: number, maxAttempts: number, delayMs: number);
+    dispose(): void;
+}
+export type CompactionStatusReason = "manual" | "threshold" | "overflow";
+export declare class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, reason: CompactionStatusReason);
+}
+export declare class BranchSummaryStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI);
+}
+export declare class IdleStatus implements Component {
+    invalidate(): void;
+    render(width: number): string[];
+}
+//# sourceMappingURL=status-indicator.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/theme-selector.d.ts

@@ -0,0 +1,11 @@
+import { Container, SelectList } from "@earendil-works/pi-tui";
+/**
+ * Component that renders a theme selector
+ */
+export declare class ThemeSelectorComponent extends Container {
+    private selectList;
+    private onPreview;
+    constructor(currentTheme: string, onSelect: (themeName: string) => void, onCancel: () => void, onPreview: (themeName: string) => void);
+    getSelectList(): SelectList;
+}
+//# sourceMappingURL=theme-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/thinking-selector.d.ts

@@ -0,0 +1,11 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { Container, SelectList } from "@earendil-works/pi-tui";
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export declare class ThinkingSelectorComponent extends Container {
+    private selectList;
+    constructor(currentLevel: ThinkingLevel, availableLevels: ThinkingLevel[], onSelect: (level: ThinkingLevel) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+}
+//# sourceMappingURL=thinking-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/tool-execution.d.ts

@@ -0,0 +1,63 @@
+import { Container, type TUI } from "@earendil-works/pi-tui";
+import type { ToolDefinition } from "../../../core/extensions/types.ts";
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    imageWidthCells?: number;
+}
+export declare class ToolExecutionComponent extends Container {
+    private contentBox;
+    private contentText;
+    private selfRenderContainer;
+    private callRendererComponent?;
+    private resultRendererComponent?;
+    private rendererState;
+    private imageComponents;
+    private imageSpacers;
+    private toolName;
+    private toolCallId;
+    private args;
+    private expanded;
+    private showImages;
+    private imageWidthCells;
+    private isPartial;
+    private toolDefinition?;
+    private builtInToolDefinition?;
+    private ui;
+    private cwd;
+    private executionStarted;
+    private argsComplete;
+    private result?;
+    private convertedImages;
+    private hideComponent;
+    constructor(toolName: string, toolCallId: string, args: any, options: ToolExecutionOptions | undefined, toolDefinition: ToolDefinition<any, any> | undefined, ui: TUI, cwd: string);
+    private getCallRenderer;
+    private getResultRenderer;
+    private hasRendererDefinition;
+    private getRenderShell;
+    private getRenderContext;
+    private createCallFallback;
+    private createResultFallback;
+    updateArgs(args: any): void;
+    markExecutionStarted(): void;
+    setArgsComplete(): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        }>;
+        details?: any;
+        isError: boolean;
+    }, isPartial?: boolean): void;
+    private maybeConvertImagesForKitty;
+    setExpanded(expanded: boolean): void;
+    setShowImages(show: boolean): void;
+    setImageWidthCells(width: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    private updateDisplay;
+    private getTextOutput;
+    private formatToolExecution;
+}
+//# sourceMappingURL=tool-execution.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/tree-selector.d.ts

@@ -0,0 +1,94 @@
+import { type Component, Container, type Focusable } from "@earendil-works/pi-tui";
+import type { SessionTreeNode } from "../../../core/session-manager.ts";
+/** Filter mode for tree display */
+export type FilterMode = "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+declare class TreeList implements Component {
+    private flatNodes;
+    private filteredNodes;
+    private selectedIndex;
+    private currentLeafId;
+    private maxVisibleLines;
+    private filterMode;
+    private searchQuery;
+    private toolCallMap;
+    private multipleRoots;
+    private showLabelTimestamps;
+    private activePathIds;
+    private visibleParentMap;
+    private visibleChildrenMap;
+    private lastSelectedId;
+    private foldedNodes;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    onCopy?: (text: string | undefined) => void;
+    onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, maxVisibleLines: number, initialSelectedId?: string, initialFilterMode?: FilterMode);
+    /**
+     * Find the index of the nearest visible entry, walking up the parent chain if needed.
+     * Returns the index in filteredNodes, or the last index as fallback.
+     */
+    private findNearestVisibleIndex;
+    /** Build the set of entry IDs on the path from root to current leaf */
+    private buildActivePath;
+    private flattenTree;
+    private applyFilter;
+    /**
+     * Recompute indentation/connectors for the filtered view
+     *
+     * Filtering can hide intermediate entries; descendants attach to the nearest visible ancestor.
+     * Keep indentation semantics aligned with flattenTree() so single-child chains don't drift right.
+     */
+    private recalculateVisualStructure;
+    /** Get searchable text content from a node */
+    private getSearchableText;
+    invalidate(): void;
+    getSearchQuery(): string;
+    getSelectedNode(): SessionTreeNode | undefined;
+    copySelected(): void;
+    updateNodeLabel(entryId: string, label: string | undefined, labelTimestamp?: string): void;
+    private getStatusLabels;
+    render(width: number): string[];
+    private getEntryDisplayText;
+    private formatLabelTimestamp;
+    private extractContent;
+    private extractFullContent;
+    private getEntryCopyText;
+    private hasTextContent;
+    private formatToolCall;
+    handleInput(keyData: string): void;
+    /**
+     * Whether a node can be folded. A node is foldable if it has visible children
+     * and is either a root (no visible parent) or a segment start (visible parent
+     * has multiple visible children).
+     */
+    private isFoldable;
+    /**
+     * Find the index of the next branch segment start in the given direction.
+     * A segment start is the first child of a branch point.
+     *
+     * "up" walks the visible parent chain; "down" walks visible children
+     * (always following the first child).
+     */
+    private findBranchSegmentStart;
+}
+/**
+ * Component that renders a session tree selector for navigation
+ */
+export declare class TreeSelectorComponent extends Container implements Focusable {
+    private treeList;
+    private labelInput;
+    private labelInputContainer;
+    private treeContainer;
+    private onLabelChangeCallback?;
+    onCopy?: (text: string | undefined) => void;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string) => void, onCancel: () => void, onLabelChange?: (entryId: string, label: string | undefined) => void, initialSelectedId?: string, initialFilterMode?: FilterMode);
+    private showLabelInput;
+    private hideLabelInput;
+    handleInput(keyData: string): void;
+    getTreeList(): TreeList;
+}
+export {};
+//# sourceMappingURL=tree-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/trust-selector.d.ts

@@ -0,0 +1,23 @@
+import { Container } from "@earendil-works/pi-tui";
+import { type ProjectTrustOption, type ProjectTrustStoreEntry } from "../../../core/trust-manager.ts";
+export type TrustSelection = Pick<ProjectTrustOption, "trusted" | "updates">;
+export interface TrustSelectorOptions {
+    cwd: string;
+    savedDecision: ProjectTrustStoreEntry | null;
+    projectTrusted: boolean;
+    onSelect: (selection: TrustSelection) => void;
+    onCancel: () => void;
+}
+export declare class TrustSelectorComponent extends Container {
+    private selectedIndex;
+    private readonly listContainer;
+    private readonly trustOptions;
+    private readonly savedDecision;
+    private readonly onSelectCallback;
+    private readonly onCancelCallback;
+    constructor(options: TrustSelectorOptions);
+    private isSavedOption;
+    private updateList;
+    handleInput(keyData: string): void;
+}
+//# sourceMappingURL=trust-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/user-message-selector.d.ts

@@ -0,0 +1,30 @@
+import { type Component, Container } from "@earendil-works/pi-tui";
+interface UserMessageItem {
+    id: string;
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Custom user message list component with selection
+ */
+declare class UserMessageList implements Component {
+    private messages;
+    private selectedIndex;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    private maxVisible;
+    constructor(messages: UserMessageItem[], initialSelectedId?: string);
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a user message selector for branching
+ */
+export declare class UserMessageSelectorComponent extends Container {
+    private messageList;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void, initialSelectedId?: string);
+    getMessageList(): UserMessageList;
+}
+export {};
+//# sourceMappingURL=user-message-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/user-message.d.ts

@@ -0,0 +1,14 @@
+import { Container, type MarkdownTheme } from "@earendil-works/pi-tui";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    private text;
+    private markdownTheme;
+    private outputPad;
+    constructor(text: string, markdownTheme?: MarkdownTheme, outputPad?: number);
+    setOutputPad(padding: number): void;
+    private rebuild;
+    render(width: number): string[];
+}
+//# sourceMappingURL=user-message.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/interactive/components/visual-truncate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared utility for truncating text to visual lines (accounting for line wrapping).
+ * Used by both tool-execution.ts and bash-execution.ts for consistent behavior.
+ */
+export interface VisualTruncateResult {
+    /** The visual lines to display */
+    visualLines: string[];
+    /** Number of visual lines that were skipped (hidden) */
+    skippedCount: number;
+}
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export declare function truncateToVisualLines(text: string, maxVisualLines: number, width: number, paddingX?: number): VisualTruncateResult;
+//# sourceMappingURL=visual-truncate.d.ts.map