@sayknow-cli/coding-agent 0.4.2 → 0.4.4

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -0,0 +1,81 @@
+import type { Component, TUI } from "@sayknow-cli/tui";
+import { KeybindingsManager } from "../../config/keybindings";
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
+import { type Theme } from "../../modes/theme/theme";
+import type { InteractiveModeContext } from "../../modes/types";
+export declare class ExtensionUiController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    captureSessionUiCleanup(): () => void;
+    /**
+     * Initialize the hook system with TUI-based UI context.
+     */
+    initHooksAndCustomTools(): Promise<void>;
+    setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    initializeHookRunner(uiContext: ExtensionUIContext, _hasUI: boolean): void;
+    createBackgroundUiContext(): ExtensionUIContext;
+    /**
+     * Emit session event to all extension tools.
+     */
+    emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
+    /**
+     * Show a tool error in the chat.
+     */
+    showToolError(toolName: string, error: string): void;
+    /**
+     * Set hook status text in the footer.
+     */
+    setHookStatus(key: string, text: string | undefined): void;
+    /**
+     * Show a selector for hooks.
+     */
+    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    /**
+     * Hide the hook selector.
+     */
+    hideHookSelector(): void;
+    /**
+     * Show a confirmation dialog for hooks.
+     */
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    /**
+     * Show a text input for hooks.
+     */
+    showHookInput(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    /**
+     * Hide the hook input.
+     */
+    hideHookInput(): void;
+    /**
+     * Show a multi-line editor for hooks (with Ctrl+G support).
+     */
+    showHookEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Hide the hook editor.
+     */
+    hideHookEditor(): void;
+    /**
+     * Show a notification for hooks.
+     */
+    showHookNotify(message: string, type?: "info" | "warning" | "error"): void;
+    /**
+     * Show a custom component with keyboard focus.
+     */
+    showHookCustom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => (Component & {
+        dispose?(): void;
+    }) | Promise<Component & {
+        dispose?(): void;
+    }>, options?: {
+        overlay?: boolean;
+    }): Promise<T>;
+    /**
+     * Show an extension error in the UI.
+     */
+    addExtensionTerminalInputListener(handler: TerminalInputHandler): () => void;
+    clearHookWidgets(): void;
+    clearExtensionTerminalInputListeners(): void;
+    showExtensionError(extensionPath: string, error: string): void;
+}

package/dist/types/modes/controllers/goal-mode-controller.d.ts

@@ -0,0 +1,69 @@
+import { type Goal } from "../../goals/state";
+import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
+import type { SessionContext, SessionManager } from "../../session/session-manager";
+import type { SubmittedUserInput } from "../types";
+import type { ModeGate } from "./mode-gate";
+interface GoalModeControllerContext {
+    readonly session: AgentSession;
+    readonly sessionManager: SessionManager;
+    readonly modeGate: ModeGate;
+    get planModeActive(): boolean;
+    get inputCallback(): ((input: SubmittedUserInput) => void) | undefined;
+    get hasPendingSubmission(): boolean;
+    get hasPendingImages(): boolean;
+    get editorText(): string;
+    startPendingSubmission(input: {
+        text: string;
+        customType?: string;
+        display?: boolean;
+    }): SubmittedUserInput;
+    showStatus(message: string): void;
+    showWarning(message: string): void;
+    showError(message: string): void;
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showHookSelector(title: string, options: string[]): Promise<string | undefined>;
+    showHookEditor(title: string, options?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    updateGoalModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+}
+/** Owns goal-mode state, continuation scheduling, commands, and session restoration. */
+export declare class GoalModeController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: GoalModeControllerContext);
+    get enabled(): boolean;
+    get paused(): boolean;
+    setEnabledForCompatibility(enabled: boolean): void;
+    setPausedForCompatibility(paused: boolean): void;
+    beforeGetUserInput(): Promise<void>;
+    scheduleContinuation(): void;
+    cancelContinuation(): void;
+    onPendingSubmissionFinished(customType?: string): void;
+    onUserSubmission(): void;
+    handleSessionEvent(event: AgentSessionEvent): Promise<void>;
+    /**
+     * Restore durable goal state. Recovery hydration deliberately performs only
+     * in-memory restoration: it neither consumes a pending request nor repairs
+     * invalid persisted state by writing a fallback mode entry.
+     */
+    restoreFromSession(sessionContext: SessionContext, options?: {
+        recoveryHydration?: boolean;
+    }): Promise<boolean>;
+    handleCommand(rest?: string): Promise<void>;
+    enter(options: {
+        objective?: string;
+        provenance?: Goal["provenance"];
+        resume?: boolean;
+        silent?: boolean;
+    }): Promise<void>;
+    exit(options?: {
+        silent?: boolean;
+        paused?: boolean;
+        reason?: "completed" | "paused" | "dropped";
+    }): Promise<void>;
+}
+export {};

package/dist/types/modes/controllers/input-controller.d.ts

@@ -0,0 +1,55 @@
+import { type AutocompleteProvider, type SlashCommand } from "@sayknow-cli/tui";
+import { type ComposerSubmissionOptions, type InteractiveModeContext } from "../../modes/types";
+import { loadPastedImageBatch } from "../../utils/pasted-image-loading";
+import { ActionRegistry } from "../action-registry";
+import type { PasteTextContext } from "../components/custom-editor";
+export declare const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5000;
+export declare const BACKGROUND_FOLD_DOUBLE_PRESS_MS = 750;
+interface InputControllerDependencies {
+    loadPastedImageBatch?: typeof loadPastedImageBatch;
+}
+export declare class InputController {
+    #private;
+    private ctx;
+    readonly actionRegistry: ActionRegistry<void>;
+    constructor(ctx: InteractiveModeContext, dependencies?: InputControllerDependencies);
+    setupKeyHandlers(): void;
+    setupEditorSubmitHandler(): void;
+    submitText(text: string, composer: ComposerSubmissionOptions): Promise<void>;
+    handleCtrlC(): void;
+    handleCtrlD(): void;
+    handleCtrlZ(): void;
+    toggleQueuePane(): void;
+    sendNow(): Promise<void>;
+    handleDequeue(): void;
+    /** Send editor text as a follow-up message (queued behind current stream). */
+    handleFollowUp(): Promise<void>;
+    /** Send editor text explicitly as a queued next-turn message. */
+    handleQueueSubmit(): Promise<void>;
+    restoreLatestQueuedMessageToEditor(): number;
+    restoreQueuedMessagesToEditor(options?: {
+        abort?: boolean;
+        currentText?: string;
+    }): number;
+    handleBackgroundCommand(): void;
+    handleForegroundToolBackgroundFold(): boolean;
+    handleTextPaste(text: string, context: PasteTextContext): boolean | Promise<boolean>;
+    handleImagePaste(): Promise<boolean>;
+    createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;
+    /** Copy the current editor line to the system clipboard. */
+    handleCopyCurrentLine(): void;
+    /** Copy current prompt text to system clipboard. */
+    handleCopyPrompt(): void;
+    openCommandPalette(): void;
+    cycleThinkingLevel(): void;
+    cycleRoleModel(options?: {
+        temporary?: boolean;
+    }): Promise<void>;
+    toggleToolOutputExpansion(): void;
+    scrollTmuxToPreviousUserInput(): void;
+    setToolsExpanded(expanded: boolean): void;
+    toggleThinkingBlockVisibility(): void;
+    openExternalEditor(): Promise<void>;
+    registerExtensionShortcuts(): void;
+}
+export {};

package/dist/types/modes/controllers/mode-gate.d.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMode = "goal" | "plan";
+/** Owns the mutual-exclusion state for interactive goal and plan modes. */
+export declare class ModeGate {
+    #private;
+    get activeMode(): ExclusiveMode | undefined;
+    enter(mode: ExclusiveMode): boolean;
+    exit(mode: ExclusiveMode): void;
+}

package/dist/types/modes/controllers/plan-mode-controller.d.ts

@@ -0,0 +1,65 @@
+import type { CompactionOutcome } from "@sayknow-cli/agent-core/compaction";
+import { Container, type KeyId } from "@sayknow-cli/tui";
+import { type PlanApprovalDetails } from "../../plan-mode/approved-plan";
+import type { AgentSession } from "../../session/agent-session";
+import type { SessionContext, SessionManager } from "../../session/session-manager";
+import { type PlanPreviewOptions, type PlanPreviewResult } from "../components/plan-preview-overlay";
+import type { SubmittedUserInput } from "../types";
+import type { ModeGate } from "./mode-gate";
+type PlanModeControllerContext = {
+    readonly session: AgentSession;
+    readonly sessionManager: SessionManager;
+    readonly modeGate: ModeGate;
+    readonly chatContainer: Container;
+    readonly inputCallback: ((input: SubmittedUserInput) => void) | undefined;
+    readonly externalEditorKey: string | undefined;
+    readonly externalEditorKeys: readonly KeyId[];
+    startPendingSubmission(input: {
+        text: string;
+    }): SubmittedUserInput;
+    addChatChild(child: Container): void;
+    requestRender(full?: boolean): void;
+    stopUi(): void;
+    startUi(): void;
+    showStatus(message: string): void;
+    showWarning(message: string): void;
+    showError(message: string): void;
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showPlanPreview(content: string | null, options?: PlanPreviewOptions): Promise<PlanPreviewResult>;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    updatePlanModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    handleClearCommand(): Promise<boolean>;
+    handleCompactCommand(instructions?: string): Promise<CompactionOutcome>;
+    updateEditorChrome(): void;
+};
+/** Owns plan-mode state, model scope, plan review, approval, and restoration. */
+export declare class PlanModeController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: PlanModeControllerContext);
+    get enabled(): boolean;
+    get paused(): boolean;
+    get planFilePath(): string | undefined;
+    setEnabledForCompatibility(enabled: boolean): void;
+    setPausedForCompatibility(paused: boolean): void;
+    setPlanFilePathForCompatibility(planFilePath: string | undefined): void;
+    clearReview(): void;
+    restoreFromSession(sessionContext: SessionContext): Promise<void>;
+    enter(options?: {
+        planFilePath?: string;
+        workflow?: "parallel" | "iterative";
+    }): Promise<void>;
+    exit(options?: {
+        silent?: boolean;
+        paused?: boolean;
+    }): Promise<void>;
+    flushPendingModelSwitch(): Promise<void>;
+    handleCommand(initialPrompt?: string): Promise<void>;
+    handleApproval(details: PlanApprovalDetails): Promise<void>;
+}
+export {};

package/dist/types/modes/controllers/runtime-mcp-command-controller.d.ts

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class MCPCommandController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Handle /mcp command and route to subcommands
+     */
+    handle(text: string): Promise<void>;
+}

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -0,0 +1,129 @@
+import type { Component, SlashCommand } from "@sayknow-cli/tui";
+import type { ModelProfileConfig } from "../../config/models-config-schema";
+import { type Settings } from "../../config/settings";
+import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
+import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
+import { proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
+import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
+import { ensureTelegramDaemonRunningDetailed, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
+import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
+import { type CommandPaletteAction } from "../components/command-palette";
+import type { NotificationsEditorOperations } from "../components/notifications-settings-editor";
+import { type PlanPreviewOptions, type PlanPreviewResult } from "../components/plan-preview-overlay";
+import type { StatusLineSettings } from "../components/tool-status-header";
+import type { JobsObserver } from "../jobs-observer";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+import type { TasksAggregator } from "../tasks-aggregator";
+import type { TranscriptItemRegistry } from "../transcript-item-registry";
+/**
+ * Snapshot the persisted status-line settings that the status-line component
+ * cares about. Preview, cancel-restore, and commit paths all share this so the
+ * previewed row count (and every other field) can never drift out of sync.
+ */
+export declare function buildStatusLineSettings(settingsInstance: Settings): StatusLineSettings;
+export interface NotificationsEditorAdapterContext {
+    settings: Settings;
+    session: Pick<InteractiveModeContext["session"], "notificationSessionController">;
+    sessionManager: Pick<InteractiveModeContext["sessionManager"], "getCwd" | "getSessionId">;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+export interface NotificationsEditorOperationDependencies {
+    getNotificationConfig: typeof getNotificationConfig;
+    maskToken: typeof maskToken;
+    buildNotificationStatusReport: typeof buildNotificationStatusReport;
+    checkNotificationHealth: typeof checkNotificationHealth;
+    sendNotificationTest: typeof sendNotificationTest;
+    recoverNotifications: typeof recoverNotifications;
+    sanitizeDiagnostic: typeof sanitizeDiagnostic;
+    ensureTelegramDaemonRunningDetailed: typeof ensureTelegramDaemonRunningDetailed;
+    runTelegramSetup: typeof runTelegramSetup;
+    proposedTelegramIdentity: typeof proposedTelegramIdentity;
+    reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
+    saveTelegramInactive: typeof saveTelegramInactive;
+    removeTelegramConfiguration: typeof removeTelegramConfiguration;
+    unregisterNotificationRoot: typeof unregisterNotificationRoot;
+    reloadTelegramDaemon(settings: Settings): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    restartTelegramDaemon(settings: Settings): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    stopTelegramDaemon(settings: Settings): Promise<{
+        ok: boolean;
+        message: string;
+        before?: {
+            health?: string;
+        };
+    }>;
+}
+/**
+ * Concrete service adapter for the direct Notifications settings tab. Secrets remain in this closure's
+ * WeakMap and are never exposed through the editor's safe draft contract.
+ */
+export declare function createNotificationsEditorOperations(ctx: NotificationsEditorAdapterContext, overrides?: Partial<NotificationsEditorOperationDependencies>): NotificationsEditorOperations;
+export declare class SelectorController {
+    #private;
+    private ctx;
+    private readonly clipboard;
+    constructor(ctx: InteractiveModeContext, credentialAutoImportStateStore?: CredentialAutoImportStateStore, clipboard?: (text: string) => void);
+    isTranscriptViewerOpen(): boolean;
+    refreshTranscriptViewer(identityMap?: ReadonlyMap<string, string>): void;
+    /**
+     * Shows a selector component in place of the editor.
+     * @param create Factory that receives a `done` callback and returns the component and focus target
+     */
+    showSelector(create: (done: () => void) => {
+        component: Component;
+        focus: Component;
+    }): void;
+    showCommandPalette(commands: SlashCommand[], actions: CommandPaletteAction[], executeSlashCommand: (name: string) => Promise<void>): void;
+    showProviderOnboarding(): void;
+    showCustomModelPresetWizard(snapshot: ModelProfileConfig): void;
+    showCustomProviderWizard(): void;
+    showEffortSelector(): void;
+    showSettingsSelector(): void;
+    showThemeSelector(): void;
+    showPetSelector(): void;
+    showHistorySearch(): void;
+    /**
+     * Show the Extension Control Center dashboard.
+     * Replaces /status with a unified view of all providers and extensions.
+     */
+    showExtensionsDashboard(): Promise<void>;
+    /**
+     * Show the Agent Control Center dashboard.
+     */
+    showAgentsDashboard(): Promise<void>;
+    /**
+     * Handle setting changes from the settings selector.
+     * Most settings are saved directly via SettingsManager in the definitions.
+     * This handles side effects and session-specific settings.
+     */
+    handleSettingChange(id: string, value: unknown): void;
+    showModelSelector(options?: {
+        temporaryOnly?: boolean;
+    }): void;
+    showPluginSelector(mode?: "install" | "uninstall"): Promise<void>;
+    showUserMessageSelector(): void;
+    showTreeSelector(): void;
+    showSessionSelector(): Promise<void>;
+    handleResumeSession(sessionPath: string): Promise<void>;
+    handleSessionDeleteCommand(): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
+    showDebugSelector(): void;
+    showSessionObserver(registry: SessionObserverRegistry): void;
+    showSessionsDashboard(): Promise<void>;
+    showTranscriptViewer(registry: TranscriptItemRegistry): void;
+    showPlanPreview(content: string | null, options?: PlanPreviewOptions): Promise<PlanPreviewResult>;
+    /**
+     * Jobs overlay: navigate ongoing monitor + cron jobs (Monitors then Crons,
+     * newest-first), drill into per-type detail, and cancel/delete with a y/N
+     * confirm. Built from nested SelectLists (list -> detail -> confirm) so focus
+     * stays on the active SelectList.
+     */
+    showJobsOverlay(observer: JobsObserver): void;
+    showTasksPane(aggregator: TasksAggregator): void;
+}

package/dist/types/modes/controllers/ssh-command-controller.d.ts

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class SSHCommandController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Handle /ssh command and route to subcommands
+     */
+    handle(text: string): Promise<void>;
+}

package/dist/types/modes/controllers/stt-controller.d.ts

@@ -0,0 +1,26 @@
+interface SttEditor {
+    cursorOverride: string | undefined;
+    cursorOverrideWidth: number | undefined;
+    getUseTerminalCursor(): boolean;
+    insertText(text: string): void;
+    setUseTerminalCursor(enabled: boolean): void;
+}
+interface SttUi {
+    getShowHardwareCursor(): boolean;
+    requestRender(): void;
+    setShowHardwareCursor(enabled: boolean): void;
+}
+export interface SttModeContext {
+    editor: SttEditor;
+    showStatus(message: string): void;
+    showWarning(message: string): void;
+    ui: SttUi;
+    updateEditorChrome(): void;
+}
+/** Coordinates STT state with the interactive composer presentation. */
+export declare class SttModeController {
+    #private;
+    toggle(ctx: SttModeContext): Promise<void>;
+    dispose(ctx: Pick<SttModeContext, "editor" | "ui">): void;
+}
+export {};

package/dist/types/modes/controllers/todo-command-controller.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveModeContext } from "../types";
+export declare class TodoCommandController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    handleTodoCommand(args: string): Promise<void>;
+}

package/dist/types/modes/emoji-autocomplete.d.ts

@@ -0,0 +1,16 @@
+import type { AutocompleteItem } from "@sayknow-cli/tui";
+export declare function getEmojiSuggestions(textBeforeCursor: string): {
+    items: AutocompleteItem[];
+    prefix: string;
+} | null;
+export declare function applyEmojiCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+};
+export declare function tryEmojiInlineReplace(textBeforeCursor: string): {
+    replaceLen: number;
+    insert: string;
+} | null;
+export declare function isEmojiPrefix(prefix: string): boolean;
+export declare function expandEmoticons(text: string): string;

package/dist/types/modes/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run modes for the coding agent.
+ */
+export { runAcpMode } from "./acp";
+export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
+export { type PrintModeOptions, runPrintMode } from "./print-mode";