@sayknow-cli/coding-agent 0.3.6 → 0.3.7

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -0,0 +1,57 @@
+import { type CanonicalSkcWorkflowSkill } from "./active-state";
+export { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION, WORKFLOW_STATE_VERSION, } from "./workflow-state-version";
+export type { CanonicalSkcWorkflowSkill };
+export type WorkflowStateMutationOwner = "skc-state-cli" | "skc-runtime" | "skc-hook";
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+export interface WorkflowStateContentChecksum {
+    algorithm: "sha256";
+    value: string;
+    covered_path: string;
+    computed_at: string;
+}
+export interface WorkflowStateReceipt {
+    version: 1;
+    skill: CanonicalSkcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    state_path: string;
+    storage_path: string;
+    mutated_at: string;
+    fresh_until: string;
+    status: WorkflowStateReceiptStatus;
+    mutation_id: string;
+    verb?: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced?: boolean;
+    paths?: string[];
+    content_sha256?: WorkflowStateContentChecksum;
+}
+export interface AuditEntry {
+    ts: string;
+    skill?: string;
+    category: string;
+    verb: string;
+    owner: WorkflowStateMutationOwner;
+    mutation_id: string;
+    from_phase?: string;
+    to_phase?: string;
+    forced: boolean;
+    paths: string[];
+}
+export declare function workflowModeStateFileName(skill: CanonicalSkcWorkflowSkill): string;
+export declare function workflowStateStoragePath(cwd: string, skill: CanonicalSkcWorkflowSkill, sessionId?: string): string;
+export declare function workflowActiveStatePath(cwd: string, sessionId?: string): string;
+export declare function buildWorkflowStateReceipt(input: {
+    cwd: string;
+    skill: CanonicalSkcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    sessionId?: string;
+    nowIso?: string;
+    mutationId?: string;
+}): WorkflowStateReceipt;
+export declare function workflowReceiptStatus(receipt: WorkflowStateReceipt | undefined, nowMs?: number): WorkflowStateReceiptStatus | undefined;
+export declare function canonicalWorkflowSkill(value: string): CanonicalSkcWorkflowSkill | null;
+export declare function sanctionedWorkflowStateCommand(skill: CanonicalSkcWorkflowSkill): string;
+export declare function describeWorkflowStateContract(skill: CanonicalSkcWorkflowSkill): string[];

package/dist/types/skill-state/workflow-state-version.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_VERSION = 2;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -0,0 +1,18 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+export type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * Commands advertised to ACP clients. Entries without a text-mode `handle`
+ * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't
+ * see commands it cannot drive.
+ */
+export declare const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[];
+/**
+ * Dispatch a slash command in ACP/text mode. Returns:
+ * - `false` when no builtin matched (or matched a TUI-only entry); the caller
+ *   should forward the input as a prompt.
+ * - `{ consumed: true }` when the command handled the input entirely.
+ * - `{ prompt }` when the command was handled but a residual prompt should be
+ *   sent to the model.
+ */
+export declare function executeAcpBuiltinSlashCommand(text: string, runtime: AcpBuiltinCommandRuntime): Promise<AcpBuiltinSlashCommandResult>;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -0,0 +1,24 @@
+import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
+export type { BuiltinSlashCommand, SubcommandDef } from "./types";
+/** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export declare function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined;
+/** Builtin command metadata used for slash-command autocomplete and help text. */
+export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;
+/**
+ * Unified registry exposed for cross-mode tooling. Each spec carries at least
+ * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the
+ * ACP dispatcher requires `handle` and skips TUI-only entries.
+ */
+export declare const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommandSpec>;
+/**
+ * Execute a builtin slash command in the interactive TUI.
+ *
+ * Returns `false` when no builtin matched. Returns `true` when a command
+ * consumed the input entirely. Returns a `string` when the command was handled
+ * but remaining text should be sent as a prompt.
+ */
+export declare function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<string | boolean>;
+/** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
+export declare function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined;
+export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };

package/dist/types/slash-commands/helpers/context-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/context` ACP-mode text. Tries the rich breakdown first
+ * (categories + auto-compact buffer + free slack) and falls back to the
+ * minimal "window/used" lines when the breakdown helper throws.
+ */
+export declare function buildContextReportText(runtime: SlashCommandRuntime): string;

package/dist/types/slash-commands/helpers/fast-status-report.d.ts

@@ -0,0 +1,82 @@
+import type { Model } from "@sayknow-cli/ai";
+/**
+ * A single line in the `/fast status` report: a labelled model and whether fast
+ * mode is effective for it. The `fast` flag is resolved by the caller
+ * (`buildFastStatusReport`) so each row can use the correct service tier — the
+ * main session tier for the current model / `modelRoles` roles, or the subagent
+ * tier (`task.serviceTier`) for `task.agentModelOverrides` roles.
+ */
+export interface FastStatusRow {
+    /** Display label, e.g. "현재 모델", "DEFAULT", "EXECUTOR". */
+    label: string;
+    /** Resolved model for this row, if any. */
+    model?: Model;
+    /** Whether fast mode is effective for this row's model. */
+    fast: boolean;
+}
+export interface FormatFastStatusReportArgs {
+    rows: FastStatusRow[];
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/** Title line of the `/fast status` report. */
+export declare const FAST_STATUS_TITLE = "Fast \uBAA8\uB4DC \uC0C1\uD0DC";
+/** The inactive marker shown for rows where fast mode does not apply. */
+export declare const FAST_STATUS_OFF = "off";
+/**
+ * Format a multiline `/fast status` report. Pure and shared by the CLI
+ * (`handle`) and TUI (`handleTui`) command branches so the two never drift.
+ * Each row's fast/off state is decided by the caller (see
+ * {@link buildFastStatusReport}) so per-row service-tier differences are honored.
+ */
+export declare function formatFastStatusReport(args: FormatFastStatusReportArgs): string;
+/** Minimal session surface needed to build the `/fast status` report. */
+export interface FastStatusSessionLike {
+    readonly model?: Model;
+    /** Fast predicate against the main session tier (current model + `modelRoles`). */
+    isFastForProvider(provider?: string): boolean;
+    /**
+     * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
+     * Used for the current-model row so it matches what the next request does.
+     * Optional so lightweight fakes can omit it; falls back to `isFastForProvider`.
+     */
+    isFastModeActive?(): boolean;
+    /** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
+    isFastForSubagentProvider(provider?: string): boolean;
+    resolveRoleModelWithThinking(role: string): {
+        model?: Model;
+    };
+}
+/** A role to enumerate in the report, with the tier source its subagent runs under. */
+export interface FastStatusRoleTarget {
+    id: string;
+    label: string;
+    /**
+     * True for `task.agentModelOverrides` roles (executor/architect/planner/critic)
+     * that run under `task.serviceTier`; false for `modelRoles` roles (default)
+     * that run under the main session tier.
+     */
+    isSubagentRole: boolean;
+}
+export interface BuildFastStatusReportArgs {
+    session: FastStatusSessionLike;
+    /** Role targets to enumerate, in display order. */
+    roleTargets: ReadonlyArray<FastStatusRoleTarget>;
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/**
+ * Build the `/fast status` report from a live session: the active/current model
+ * followed by each assigned role (subagent) model. Unassigned roles are skipped
+ * so the report mirrors the `/model` selector, which only badges assigned roles.
+ *
+ * Subagent roles (`task.agentModelOverrides`) are evaluated against the
+ * effective subagent tier (`task.serviceTier`), while the current model and
+ * `modelRoles` roles use the main session tier — matching where each model
+ * actually runs.
+ */
+export declare function buildFastStatusReport(args: BuildFastStatusReportArgs): string;

package/dist/types/slash-commands/helpers/format.d.ts

@@ -0,0 +1,10 @@
+import { type Theme } from "../../modes/theme/theme";
+/** Format a millisecond duration as a coarse-grained human label. */
+export declare function formatDuration(ms: number): string;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
+/**
+ * Render an ASCII progress bar with a trailing percent label.
+ * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
+ */
+export declare function renderAsciiBar(fraction: number | undefined, width?: number, uiTheme?: ProgressBarTheme): string;
+export {};

package/dist/types/slash-commands/helpers/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/mcp` handler. Shared by both dispatchers via the spec. */
+export declare function handleMcpAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/parse.d.ts

@@ -0,0 +1,33 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+export interface ParsedSubcommand {
+    verb: string;
+    rest: string;
+}
+export type ConfigScope = "user" | "project";
+export interface NamedScopeArgs {
+    name?: string;
+    scope: ConfigScope;
+    error?: string;
+}
+/**
+ * Parse a slash-invocation string into `name`/`args`.
+ *
+ * The separator is the earliest whitespace or `:` character so that both
+ * `/foo bar` and `/foo:bar` map to `{ name: "foo", args: "bar" }`.
+ */
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+/** Mark a command as fully consumed in the ACP shape. */
+export declare function commandConsumed(): {
+    consumed: true;
+};
+/** Emit a usage/error message and consume the command. */
+export declare function usage(text: string, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;
+/** Split `<verb> <rest>` on the first whitespace; lowercases `verb`. */
+export declare function parseSubcommand(input: string): ParsedSubcommand;
+export declare function errorMessage(error: unknown): string;
+/**
+ * Parse `<name?> [--scope project|user]`-style argument strings used by
+ * remove/rm-style subcommands. `name` is optional so callers can surface
+ * "name required" diagnostics with their own messaging.
+ */
+export declare function parseNamedScopeArgs(rest: string, invalidScopeMessage: string): NamedScopeArgs;

package/dist/types/slash-commands/helpers/ssh.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/ssh` handler. Shared by both dispatchers via the spec. */
+export declare function handleSshAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/todo.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/todo` handler. Shared by both dispatchers via the spec. */
+export declare function handleTodoAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/slash-commands/helpers/usage-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
+ * session exposes `fetchUsageReports`; otherwise falls back to the local
+ * session-manager tallies.
+ */
+export declare function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string>;

package/dist/types/slash-commands/types.d.ts

@@ -0,0 +1,120 @@
+import type { Settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession } from "../session/agent-session";
+import type { SessionManager } from "../session/session-manager";
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+    name: string;
+    description: string;
+    /** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+    usage?: string;
+}
+/** Declarative builtin slash command metadata used by autocomplete and help UI. */
+export interface BuiltinSlashCommand {
+    name: string;
+    description: string;
+    /** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
+    subcommands?: SubcommandDef[];
+    /** Static inline hint when command takes a simple argument (no subcommands). */
+    inlineHint?: string;
+    /** Higher values sort earlier in TUI slash-command autocomplete. */
+    priority?: number;
+}
+/** Parsed slash-command text after stripping the leading "/". */
+export interface ParsedSlashCommand {
+    name: string;
+    args: string;
+    text: string;
+}
+/**
+ * Result returned by a slash-command handler.
+ *
+ * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ prompt: string }` — command handled, pass `prompt` through as the new
+ *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
+ */
+export type SlashCommandResult = undefined | {
+    consumed: true;
+} | {
+    prompt: string;
+};
+/**
+ * Runtime visible to slash-command handlers that run in text/ACP mode.
+ *
+ * Both the TUI dispatcher (when invoking a `handle` via its adapter) and the
+ * ACP dispatcher pass this shape. Implementations MUST NOT depend on TUI-only
+ * state (editor, selectors, status line).
+ */
+export interface SlashCommandRuntime {
+    session: AgentSession;
+    sessionManager: SessionManager;
+    settings: Settings;
+    cwd: string;
+    /** Emit text to the operator. TUI maps to `ctx.showStatus`, ACP to `sessionUpdate`. */
+    output: (text: string) => Promise<void> | void;
+    /** Re-advertise the available command list (no-op outside ACP). */
+    refreshCommands: () => Promise<void> | void;
+    /**
+     * Reload plugin state (caches, slash command registry, project registries)
+     * and re-emit available commands. `/move` uses this so the session sees a
+     * consistent view after project-scope changes.
+     */
+    reloadPlugins: () => Promise<void>;
+    notifyTitleChanged?: () => Promise<void> | void;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+/**
+ * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
+ * mode context plus the background-detach hook. Intentionally narrower than
+ * `SlashCommandRuntime` so existing callers can keep building it from just
+ * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
+ * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
+ * from `ctx`.
+ */
+export interface TuiSlashCommandRuntime {
+    ctx: InteractiveModeContext;
+    handleBackgroundCommand: () => void;
+}
+/** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
+export interface SlashCommandSpec extends BuiltinSlashCommand {
+    aliases?: string[];
+    /** When false, the dispatcher refuses to handle invocations that include arguments. */
+    allowArgs?: boolean;
+    /**
+     * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
+     * when building `available_commands_update` payloads so the client receives
+     * mode-appropriate copy (e.g. `/dump` advertises "Return full transcript as
+     * plain text" in ACP rather than the TUI's clipboard-centric copy).
+     */
+    acpDescription?: string;
+    /**
+     * ACP-specific override for the advertised input hint. `subcommands`-only
+     * specs that historically advertised `<subcommand>` / `[on|off|status]` /
+     * `info|delete` to ACP clients carry the hint here so the unification does
+     * not silently drop it from `available_commands_update`.
+     */
+    acpInputHint?: string;
+    /**
+     * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
+     * and, via the TUI adapter, when no `handleTui` override is provided.
+     */
+    handle?: (command: ParsedSlashCommand, runtime: SlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+    /**
+     * TUI-only handler that supersedes `handle` when both are present. Use for
+     * selectors, wizards, dashboards, and anything else that requires
+     * `InteractiveModeContext`.
+     */
+    handleTui?: (command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+}
+/**
+ * @deprecated Use `SlashCommandRuntime` directly. Retained as an alias so
+ * downstream code that imported the ACP-specific name keeps compiling.
+ */
+export type AcpBuiltinCommandRuntime = SlashCommandRuntime;
+/** Result returned by `executeAcpBuiltinSlashCommand`. */
+export type AcpBuiltinSlashCommandResult = false | {
+    consumed: true;
+} | {
+    prompt: string;
+};

package/dist/types/ssh/config-writer.d.ts

@@ -0,0 +1,49 @@
+export interface SSHHostConfig {
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    description?: string;
+    compat?: boolean;
+}
+export interface SSHConfigFile {
+    hosts?: Record<string, SSHHostConfig>;
+}
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readSSHConfigFile(filePath: string): Promise<SSHConfigFile>;
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void>;
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateHostName(name: string): string | undefined;
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export declare function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export declare function removeSSHHost(filePath: string, name: string): Promise<void>;
+/**
+ * List all host names in a config file.
+ */
+export declare function listSSHHosts(filePath: string): Promise<string[]>;

package/dist/types/ssh/connection-manager.d.ts

@@ -0,0 +1,33 @@
+export interface SSHConnectionTarget {
+    name: string;
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    compat?: boolean;
+}
+export type SSHHostOs = "windows" | "linux" | "macos" | "unknown";
+export type SSHHostShell = "cmd" | "powershell" | "bash" | "zsh" | "sh" | "unknown";
+export type SshPlatform = typeof process.platform;
+export declare function supportsSshControlMaster(platform?: SshPlatform): boolean;
+export interface SSHHostInfo {
+    version: number;
+    os: SSHHostOs;
+    shell: SSHHostShell;
+    compatShell?: "bash" | "sh";
+    compatEnabled: boolean;
+}
+interface SSHArgsOptions {
+    platform?: SshPlatform;
+}
+export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
+export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;
+export declare function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo>;
+export declare function buildRemoteCommand(host: SSHConnectionTarget, command: string, options?: SSHArgsOptions): Promise<string[]>;
+export declare function ensureConnection(host: SSHConnectionTarget): Promise<void>;
+export declare function invalidateHostMetadata(hostNames: Iterable<string>): Promise<void>;
+export declare function closeConnection(hostName: string): Promise<void>;
+export declare function closeAllConnections(): Promise<void>;
+export declare function getControlPathTemplate(): string;
+export declare function getControlDir(): string;
+export {};

package/dist/types/ssh/ssh-executor.d.ts

@@ -0,0 +1,37 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export interface SSHExecutorOptions {
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Callback for streaming output chunks (already sanitized) */
+    onChunk?: (chunk: string) => void;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Remote path to mount when sshfs is available */
+    remotePath?: string;
+    /** Wrap commands in a POSIX shell for compat mode */
+    compatEnabled?: boolean;
+    /** Artifact path/id for full output storage */
+    artifactPath?: string;
+    artifactId?: string;
+}
+export interface SSHResult {
+    /** Combined stdout + stderr output (sanitized, possibly truncated) */
+    output: string;
+    /** Process exit code (undefined if killed/cancelled) */
+    exitCode: number | undefined;
+    /** Whether the command was cancelled via signal */
+    cancelled: boolean;
+    /** Whether the output was truncated */
+    truncated: boolean;
+    /** Total number of lines in the output stream */
+    totalLines: number;
+    /** Total number of bytes in the output stream */
+    totalBytes: number;
+    /** Number of lines included in the output text */
+    outputLines: number;
+    /** Number of bytes included in the output text */
+    outputBytes: number;
+    /** Artifact ID if full output was saved to artifact storage */
+    artifactId?: string;
+}
+export declare function executeSSH(host: SSHConnectionTarget, command: string, options?: SSHExecutorOptions): Promise<SSHResult>;

package/dist/types/ssh/sshfs-mount.d.ts

@@ -0,0 +1,6 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export declare function hasSshfs(): boolean;
+export declare function isMounted(path: string): Promise<boolean>;
+export declare function mountRemote(host: SSHConnectionTarget, remotePath?: string): Promise<string | undefined>;
+export declare function unmountRemote(host: SSHConnectionTarget): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;

package/dist/types/ssh/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeHostName(name: string): string;
+export declare function buildSshTarget(username: string | undefined, host: string): string;

package/dist/types/stt/downloader.d.ts

@@ -0,0 +1,9 @@
+export interface DownloadProgress {
+    stage: string;
+    percent?: number;
+}
+export interface EnsureOptions {
+    modelName?: string;
+    onProgress?: (progress: DownloadProgress) => void;
+}
+export declare function ensureSTTDependencies(options?: EnsureOptions): Promise<void>;

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

@@ -0,0 +1,3 @@
+export * from "./downloader";
+export * from "./setup";
+export * from "./stt-controller";

package/dist/types/stt/recorder.d.ts

@@ -0,0 +1,13 @@
+export interface RecordingHandle {
+    stop(): Promise<void>;
+}
+/**
+ * Returns available recording tools in priority order.
+ */
+export declare function detectRecordingTools(): string[];
+export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
+/**
+ * Verify a recorded audio file is usable.
+ * Returns the file size in bytes, or throws.
+ */
+export declare function verifyRecordingFile(filePath: string): Promise<number>;

package/dist/types/stt/setup.d.ts

@@ -0,0 +1,18 @@
+export interface STTDependencyStatus {
+    recorder: {
+        available: boolean;
+        tool: string | null;
+        installHint: string;
+    };
+    python: {
+        available: boolean;
+        path: string | null;
+        installHint: string;
+    };
+    whisper: {
+        available: boolean;
+        installHint: string;
+    };
+}
+export declare function checkDependencies(): Promise<STTDependencyStatus>;
+export declare function formatDependencyStatus(status: STTDependencyStatus): string;

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

@@ -0,0 +1,16 @@
+export type SttState = "idle" | "recording" | "transcribing";
+interface ToggleOptions {
+    showWarning(msg: string): void;
+    showStatus(msg: string): void;
+    onStateChange(state: SttState): void;
+}
+interface Editor {
+    insertText(text: string): void;
+}
+export declare class STTController {
+    #private;
+    get state(): SttState;
+    toggle(editor: Editor, options: ToggleOptions): Promise<void>;
+    dispose(): void;
+}
+export {};

package/dist/types/stt/transcriber.d.ts

@@ -0,0 +1,16 @@
+export interface TranscribeOptions {
+    modelName?: string;
+    language?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Find a usable Python command.
+ */
+export declare function resolvePython(): string | null;
+/**
+ * Transcribe a WAV file using Python openai-whisper.
+ *
+ * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
+ * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ */
+export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;