@h-rig/contracts 0.0.6-alpha.9 → 0.0.6-alpha.90

package/dist/src/ipc.d.ts

@@ -0,0 +1,247 @@
+import type { GitCheckoutInput, GitCreateBranchInput, GitCreateWorktreeInput, GitCreateWorktreeResult, GitInitInput, GitListBranchesInput, GitListBranchesResult, GitPullInput, GitPullResult, GitReadWorkingTreePatchInput, GitReadWorkingTreePatchResult, GitRemoveWorktreeInput, GitRunStackedActionInput, GitRunStackedActionResult, GitStatusInput, GitStatusResult } from "./git";
+import type { ProjectListDirectoryInput, ProjectListDirectoryResult, ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectReadFileInput, ProjectReadFileResult, ProjectWriteFileInput, ProjectWriteFileResult } from "./project";
+import type { ServerConfig } from "./server";
+import type { RigCreateAdhocRunInput, RigCreateTaskRunInput, RigDeleteRunInput, RigEnqueueTaskInput, RigGetRunLogsInput, RigGetRunLogsResult, RigGetTaskArtifactsResult, RigRunLogAppendedPayload, RigGetWorkspaceInput, RigGetWorkspaceResult, RigListWorkspacesResult, RigMutationResult, RigInterruptRunInput, RigResumeRunInput, RigResolveApprovalInput, RigResolveUserInputInput, RigSnapshot, RigStopRunInput, RigSubmitRunMessageInput } from "./rig";
+import type { TerminalClearInput, TerminalCloseInput, TerminalEvent, TerminalOpenInput, TerminalResizeInput, TerminalSessionSnapshot, TerminalWriteInput } from "./terminal";
+import type { ServerUpsertKeybindingInput, ServerUpsertKeybindingResult } from "./server";
+import type { ClientOrchestrationCommand, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationEvent, OrchestrationReadModel } from "./orchestration";
+import type { EngineEvent } from "./engine";
+import { EditorId } from "./editor";
+export interface ContextMenuItem<T extends string = string> {
+    id: T;
+    label: string;
+    destructive?: boolean;
+}
+export type DesktopUpdateStatus = "disabled" | "idle" | "checking" | "up-to-date" | "available" | "downloading" | "downloaded" | "error";
+export interface DesktopUpdateState {
+    enabled: boolean;
+    status: DesktopUpdateStatus;
+    currentVersion: string;
+    availableVersion: string | null;
+    downloadedVersion: string | null;
+    downloadPercent: number | null;
+    checkedAt: string | null;
+    message: string | null;
+    errorContext: "check" | "download" | "install" | null;
+    canRetry: boolean;
+}
+export interface DesktopUpdateActionResult {
+    accepted: boolean;
+    completed: boolean;
+    state: DesktopUpdateState;
+}
+export type RigProjectConfigStatus = "rig-config-ts" | "rig-config-json" | "legacy-task-config" | "missing";
+export interface DesktopRigSetupState {
+    rootPath: string | null;
+    ready: boolean;
+    wsUrl: string | null;
+    /**
+     * What kind of Rig configuration the project at `rootPath` has. The
+     * desktop main process probes the filesystem at boot and on
+     * `setRigRoot`; the renderer reads this to decide whether to show an
+     * onboarding banner ("Run `rig init`") or the normal dashboard.
+     */
+    configStatus: RigProjectConfigStatus;
+}
+export interface RigConfigWriteResult {
+    ok: boolean;
+    /** Absolute path to the file that was written. */
+    configPath: string;
+    /** Filesystem error message when `ok === false`. */
+    error?: string;
+    /** Updated setup state — `configStatus` reflects the post-write probe. */
+    setup: DesktopRigSetupState;
+}
+export interface RigConfigReadResult {
+    /** The raw rig.config.{ts,json} source, or null if none exists. */
+    source: string | null;
+    /** Which file was read; null when no config exists. */
+    configPath: string | null;
+}
+export interface ProjectGitRemoteInfo {
+    /** The raw origin URL, e.g. `git@github.com:humanity-org/humanwork.git`. */
+    url: string;
+    /** Parsed host, e.g. `github.com`. */
+    host: string | null;
+    /** Parsed owner/org, e.g. `humanity-org`. */
+    owner: string | null;
+    /** Parsed repository name (no `.git` suffix), e.g. `humanwork`. */
+    repo: string | null;
+}
+export interface DesktopBridge {
+    getWsUrl: () => string | null;
+    getRigSetup: () => Promise<DesktopRigSetupState>;
+    setRigRoot: (rootPath: string) => Promise<DesktopRigSetupState>;
+    /**
+     * Read the raw rig.config.{ts,json} from the project at `rootPath`.
+     * Returns `{ source: null }` when no config exists. Used by the in-app
+     * Settings screen to populate the form from the existing file.
+     */
+    readRigConfigRaw: (rootPath: string) => Promise<RigConfigReadResult>;
+    /**
+     * Write rig.config.ts to the project root atomically (temp-file + rename).
+     * Refreshes the cached setup state and returns it post-write so callers
+     * can route past the setup gate. Used by both the in-app setup wizard
+     * and the Settings → Project section.
+     */
+    writeRigConfig: (rootPath: string, source: string) => Promise<RigConfigWriteResult>;
+    /**
+     * Inspect the project's git origin to auto-fill setup wizard fields.
+     * Runs `git -C <rootPath> remote get-url origin` and parses owner/repo.
+     * Returns null when the project isn't a git repo, has no origin, or the
+     * URL doesn't match a recognized GitHub-style pattern. The wizard uses
+     * this to prefill the GitHub owner/repo step instead of making the
+     * operator type values that are already in `.git/config`.
+     */
+    getProjectGitRemote: (rootPath: string) => Promise<ProjectGitRemoteInfo | null>;
+    pickFolder: () => Promise<string | null>;
+    confirm: (message: string) => Promise<boolean>;
+    showContextMenu: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+        x: number;
+        y: number;
+    }) => Promise<T | null>;
+    openExternal: (url: string) => Promise<boolean>;
+    onMenuAction: (listener: (action: string) => void) => () => void;
+    getUpdateState: () => Promise<DesktopUpdateState>;
+    downloadUpdate: () => Promise<DesktopUpdateActionResult>;
+    installUpdate: () => Promise<DesktopUpdateActionResult>;
+    onUpdateState: (listener: (state: DesktopUpdateState) => void) => () => void;
+}
+export interface NativeApi {
+    dialogs: {
+        pickFolder: () => Promise<string | null>;
+        confirm: (message: string) => Promise<boolean>;
+    };
+    terminal: {
+        open: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        write: (input: TerminalWriteInput) => Promise<void>;
+        resize: (input: TerminalResizeInput) => Promise<void>;
+        clear: (input: TerminalClearInput) => Promise<void>;
+        restart: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        close: (input: TerminalCloseInput) => Promise<void>;
+        onEvent: (callback: (event: TerminalEvent) => void) => () => void;
+    };
+    projects: {
+        listDirectory: (input: ProjectListDirectoryInput) => Promise<ProjectListDirectoryResult>;
+        searchEntries: (input: ProjectSearchEntriesInput) => Promise<ProjectSearchEntriesResult>;
+        readFile: (input: ProjectReadFileInput) => Promise<ProjectReadFileResult>;
+        writeFile: (input: ProjectWriteFileInput) => Promise<ProjectWriteFileResult>;
+    };
+    shell: {
+        openInEditor: (cwd: string, editor: EditorId) => Promise<void>;
+        openExternal: (url: string) => Promise<void>;
+    };
+    git: {
+        listBranches: (input: GitListBranchesInput) => Promise<GitListBranchesResult>;
+        createWorktree: (input: GitCreateWorktreeInput) => Promise<GitCreateWorktreeResult>;
+        removeWorktree: (input: GitRemoveWorktreeInput) => Promise<void>;
+        createBranch: (input: GitCreateBranchInput) => Promise<void>;
+        checkout: (input: GitCheckoutInput) => Promise<void>;
+        init: (input: GitInitInput) => Promise<void>;
+        pull: (input: GitPullInput) => Promise<GitPullResult>;
+        status: (input: GitStatusInput) => Promise<GitStatusResult>;
+        readWorkingTreePatch: (input: GitReadWorkingTreePatchInput) => Promise<GitReadWorkingTreePatchResult>;
+        runStackedAction: (input: GitRunStackedActionInput) => Promise<GitRunStackedActionResult>;
+    };
+    contextMenu: {
+        show: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+            x: number;
+            y: number;
+        }) => Promise<T | null>;
+    };
+    server: {
+        getConfig: () => Promise<ServerConfig>;
+        upsertKeybinding: (input: ServerUpsertKeybindingInput) => Promise<ServerUpsertKeybindingResult>;
+    };
+    rig: {
+        getSnapshot: () => Promise<RigSnapshot>;
+        listWorkspaces: () => Promise<RigListWorkspacesResult>;
+        getWorkspace: (input: RigGetWorkspaceInput) => Promise<RigGetWorkspaceResult>;
+        getRunLogs: (input: RigGetRunLogsInput) => Promise<RigGetRunLogsResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<EngineEvent[]>;
+        createAdhocRun: (input: RigCreateAdhocRunInput) => Promise<RigMutationResult>;
+        createTaskRun: (input: RigCreateTaskRunInput) => Promise<RigMutationResult>;
+        deleteRun: (input: RigDeleteRunInput) => Promise<RigMutationResult>;
+        enqueueTask: (input: RigEnqueueTaskInput) => Promise<RigMutationResult>;
+        resumeRun: (input: RigResumeRunInput) => Promise<RigMutationResult>;
+        submitRunMessage: (input: RigSubmitRunMessageInput) => Promise<RigMutationResult>;
+        interruptRun: (input: RigInterruptRunInput) => Promise<RigMutationResult>;
+        stopRun: (input: RigStopRunInput) => Promise<RigMutationResult>;
+        resolveApproval: (input: RigResolveApprovalInput) => Promise<RigMutationResult>;
+        resolveUserInput: (input: RigResolveUserInputInput) => Promise<RigMutationResult>;
+        getTaskArtifacts: (taskId: string) => Promise<RigGetTaskArtifactsResult>;
+        onEvent: (callback: (event: EngineEvent) => void) => () => void;
+        onRunLogAppended: (callback: (payload: RigRunLogAppendedPayload) => void) => () => void;
+    };
+    orchestration: {
+        getSnapshot: () => Promise<OrchestrationReadModel>;
+        dispatchCommand: (command: ClientOrchestrationCommand) => Promise<{
+            sequence: number;
+        }>;
+        getTurnDiff: (input: OrchestrationGetTurnDiffInput) => Promise<OrchestrationGetTurnDiffResult>;
+        getFullThreadDiff: (input: OrchestrationGetFullThreadDiffInput) => Promise<OrchestrationGetFullThreadDiffResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<OrchestrationEvent[]>;
+        onDomainEvent: (callback: (event: OrchestrationEvent) => void) => () => void;
+    };
+    remote: {
+        testEndpoint: (input: {
+            host: string;
+            port: number;
+            token?: string;
+        }) => Promise<{
+            latencyMs: number;
+        }>;
+        listEndpoints: () => Promise<unknown[]>;
+        registerEndpoint: (input: {
+            alias: string;
+            host: string;
+            port: number;
+            token?: string;
+            autoConnect?: boolean;
+        }) => Promise<unknown>;
+        removeEndpoint: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        connect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        disconnect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        createRunForTask: (input: {
+            endpointId: string;
+            taskId: string;
+            runId: string;
+            workspaceId: string;
+            runtimeMode?: string;
+            interactionMode?: string;
+        }) => Promise<{
+            ok: boolean;
+        }>;
+        terminalOpen: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cwd?: string;
+            env?: Record<string, string>;
+        }) => Promise<unknown>;
+        terminalWrite: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            data: string;
+        }) => Promise<void>;
+        terminalResize: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cols: number;
+            rows: number;
+        }) => Promise<void>;
+        terminalClose: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+        }) => Promise<void>;
+    };
+}

package/dist/src/keybindings.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const MAX_KEYBINDING_VALUE_LENGTH = 64;
+export declare const MAX_WHEN_EXPRESSION_DEPTH = 64;
+export declare const MAX_SCRIPT_ID_LENGTH = 24;
+export declare const MAX_KEYBINDINGS_COUNT = 256;
+export declare const SCRIPT_RUN_COMMAND_PATTERN: Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>;
+export declare const KeybindingCommand: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+export type KeybindingCommand = typeof KeybindingCommand.Type;
+export declare const KeybindingRule: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type KeybindingRule = typeof KeybindingRule.Type;
+export declare const KeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>>;
+export type KeybindingsConfig = typeof KeybindingsConfig.Type;
+export declare const KeybindingShortcut: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly metaKey: Schema.Boolean;
+    readonly ctrlKey: Schema.Boolean;
+    readonly shiftKey: Schema.Boolean;
+    readonly altKey: Schema.Boolean;
+    readonly modKey: Schema.Boolean;
+}>;
+export type KeybindingShortcut = typeof KeybindingShortcut.Type;
+export declare const KeybindingWhenNode: Schema.Schema<KeybindingWhenNode>;
+export type KeybindingWhenNode = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "not";
+    node: KeybindingWhenNode;
+} | {
+    type: "and";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+} | {
+    type: "or";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+};
+export declare const ResolvedKeybindingRule: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>;
+export type ResolvedKeybindingRule = typeof ResolvedKeybindingRule.Type;
+export declare const ResolvedKeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>>;
+export type ResolvedKeybindingsConfig = typeof ResolvedKeybindingsConfig.Type;

package/dist/src/model.d.ts

@@ -0,0 +1,77 @@
+import { Schema } from "effect";
+import { ProviderKind } from "./orchestration";
+export declare const CODEX_REASONING_EFFORT_OPTIONS: readonly ["xhigh", "high", "medium", "low"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORT_OPTIONS)[number];
+export declare const CodexModelOptions: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+    readonly fastMode: Schema.optional<Schema.Boolean>;
+}>;
+export type CodexModelOptions = typeof CodexModelOptions.Type;
+export declare const ClaudeModelOptions: Schema.Struct<{}>;
+export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
+export declare const ProviderModelOptions: Schema.Struct<{
+    readonly codex: Schema.optional<Schema.Struct<{
+        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+        readonly fastMode: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly claude: Schema.optional<Schema.Struct<{}>>;
+}>;
+export type ProviderModelOptions = typeof ProviderModelOptions.Type;
+export declare const MODEL_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly [{
+        readonly slug: "gpt-5.4";
+        readonly name: "GPT-5.4";
+    }, {
+        readonly slug: "gpt-5.3-codex";
+        readonly name: "GPT-5.3 Codex";
+    }, {
+        readonly slug: "gpt-5.3-codex-spark";
+        readonly name: "GPT-5.3 Codex Spark";
+    }, {
+        readonly slug: "gpt-5.2-codex";
+        readonly name: "GPT-5.2 Codex";
+    }, {
+        readonly slug: "gpt-5.2";
+        readonly name: "GPT-5.2";
+    }];
+    readonly claude: readonly [{
+        readonly slug: "claude-sonnet-4-6";
+        readonly name: "Claude Sonnet 4.6";
+    }, {
+        readonly slug: "claude-opus-4-1";
+        readonly name: "Claude Opus 4.1";
+    }, {
+        readonly slug: "claude-3-7-sonnet-latest";
+        readonly name: "Claude 3.7 Sonnet";
+    }];
+};
+export type ModelOptionsByProvider = typeof MODEL_OPTIONS_BY_PROVIDER;
+type BuiltInModelSlug = ModelOptionsByProvider[ProviderKind][number]["slug"];
+export type ModelSlug = BuiltInModelSlug | (string & {});
+export declare const DEFAULT_MODEL_BY_PROVIDER: {
+    readonly codex: "gpt-5.4";
+    readonly claude: "claude-sonnet-4-6";
+};
+export declare const MODEL_SLUG_ALIASES_BY_PROVIDER: {
+    readonly codex: {
+        readonly "5.4": "gpt-5.4";
+        readonly "5.3": "gpt-5.3-codex";
+        readonly "gpt-5.3": "gpt-5.3-codex";
+        readonly "5.3-spark": "gpt-5.3-codex-spark";
+        readonly "gpt-5.3-spark": "gpt-5.3-codex-spark";
+    };
+    readonly claude: {
+        readonly sonnet: "claude-sonnet-4-6";
+        readonly opus: "claude-opus-4-1";
+        readonly "3.7-sonnet": "claude-3-7-sonnet-latest";
+    };
+};
+export declare const REASONING_EFFORT_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly ["xhigh", "high", "medium", "low"];
+    readonly claude: readonly [];
+};
+export declare const DEFAULT_REASONING_EFFORT_BY_PROVIDER: {
+    readonly codex: "high";
+    readonly claude: null;
+};
+export {};