@adhdev/daemon-core 0.9.82-rc.142 → 0.9.82-rc.144

package/dist/ipc/local-ipc-server.d.ts

@@ -0,0 +1,91 @@
+/**
+ * LocalIpcServer — generic HTTP + WebSocket IPC endpoint for daemon processes.
+ *
+ * Both daemon-cloud and daemon-standalone need a local IPC surface so
+ * external tools — the `adhdev mcp --mode ipc` MCP server and anything
+ * else that wants to issue commands without going through the cloud
+ * Worker — can connect over `ws://127.0.0.1:<port>/ipc`.
+ *
+ * Until now the implementation lived only in daemon-cloud. Standalone
+ * sessions therefore couldn't host MCP mesh tools — codex/claude config
+ * pointing at `--mode ipc` got `Cannot reach ipc daemon`. This module
+ * moves the transport into daemon-core so both daemons can mount it.
+ *
+ * The transport itself is daemon-agnostic. Cloud-specific behaviors
+ * (mesh relay, mandatory update gates) are injected via the caller's
+ * `handleCommand` hook; the IPC layer just frames/unframes JSON and
+ * routes messages.
+ */
+import { WebSocket } from 'ws';
+/** Parameters passed to `handleCommand` for each incoming ext:command frame. */
+export interface IpcCommandContext {
+    /** The raw `command` field from the message — caller decides routing. */
+    command: string;
+    /** Args provided by the client; may have been normalized by the caller. */
+    args: Record<string, unknown>;
+    /** Stable id correlating the request and the eventual ext:command_result. */
+    requestId: string;
+    /** The connected WebSocket — only needed if the caller wants to send extra events. */
+    ws: WebSocket;
+}
+/** Result reported back to the client. `result` is optional context for success. */
+export interface IpcCommandResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    /**
+     * Additional fields the caller wants merged into the response payload
+     * (e.g. the cloud daemon's mandatory-update-block fields). Reserved.
+     */
+    extra?: Record<string, unknown>;
+}
+/** Status payload returned from GET / on the IPC HTTP port. */
+export interface IpcStatusPayload {
+    ok: true;
+    pid: number;
+    wsPath: string;
+    port: number;
+    /** Arbitrary daemon-specific summary. Cloud daemon includes mesh state, etc. */
+    status: Record<string, unknown> | null;
+}
+export interface LocalIpcServerOptions {
+    /** TCP port to listen on. 19222 is the conventional default. */
+    port: number;
+    /** Build the GET / status payload. Called on every health probe. */
+    buildStatusPayload: () => Record<string, unknown> | null;
+    /** Build the welcome message sent to a freshly-connected client. */
+    buildWelcomePayload: () => Record<string, unknown>;
+    /** Handle a single ext:command frame. Caller decides routing and returns the result. */
+    handleCommand: (ctx: IpcCommandContext) => Promise<IpcCommandResult>;
+    /** Optional notification when a new client connects (lets daemon track them for broadcasts). */
+    onClientConnected?: (ws: WebSocket) => void;
+    /** Optional notification when a client disconnects. */
+    onClientDisconnected?: (ws: WebSocket) => void;
+    /** Optional logger label (defaults to "IPC"). */
+    logCategory?: string;
+}
+/**
+ * Returned controller for stopping the server and broadcasting to clients.
+ * Stored by the daemon and torn down at shutdown.
+ */
+export interface LocalIpcServerHandle {
+    /** True once `listen()` succeeded. */
+    isListening(): boolean;
+    /** Push a message to every connected client. */
+    broadcast(type: string, payload: unknown): void;
+    /** Close all client sockets + the HTTP server. */
+    close(): Promise<void>;
+}
+/**
+ * Build a JSON HTTP response describing the IPC endpoint. Exposed so caller
+ * code (and tests) can build the same shape without spinning a real server.
+ */
+export declare function buildIpcStatusHttpResponse(method: string | undefined, url: string | undefined, payload: IpcStatusPayload): {
+    statusCode: number;
+    body: Record<string, unknown>;
+};
+/**
+ * Start the local IPC server. Returns a handle the caller can use to broadcast
+ * events and tear down at shutdown.
+ */
+export declare function startLocalIpcServer(opts: LocalIpcServerOptions): Promise<LocalIpcServerHandle>;

package/dist/providers/contracts.d.ts

@@ -386,6 +386,14 @@ export interface ProviderModule {
     extensionIdPattern_flags?: string;
     compatibility?: ProviderCompatibilityEntry[];
     defaultScriptDir?: string;
+    /**
+     * v1 declarative tui block (spinner/settledPrompt/modal/dispatchOrder/etc).
+     * When present, the daemon's CliScriptRunner builds canonical
+     * (input → verdict) functions from this and injects them into provider
+     * scripts as `sdk.declarativeDetectStatus` and `sdk.declarativeParseApproval`.
+     * v0 / verified-tier providers can omit this entirely.
+     */
+    tui?: Record<string, unknown>;
     /**
      * Scripts that can run at the IDE main-page level (not just inside the extension webview session frame).
      * Default: ['listModes', 'setMode', 'listModels', 'setModel'].

package/dist/providers/native-history/antigravity-cli-transcript.d.ts

@@ -0,0 +1,100 @@
+/**
+ * antigravity-cli-transcript — Daemon-side built-in native history adapter for antigravity-cli.
+ *
+ * Antigravity CLI stores conversations in multiple complementary locations:
+ *
+ *   1. ~/.gemini/antigravity-cli/history.jsonl
+ *      Lightweight index of user prompts, one row per turn:
+ *        { conversationId: string, display: string, workspace: string, timestamp: number }
+ *
+ *   2. ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
+ *      Per-session full transcript, one row per agent step:
+ *        { source: 'USER_EXPLICIT'|'MODEL', type: string, content: string, status: 'DONE'|..., created_at: number }
+ *
+ *   3. ~/.gemini/antigravity-cli/conversations/<uuid>.pb
+ *      Protobuf binary — schema not publicly documented. Adapter extracts
+ *      printable UTF-8 text runs as best-effort content (no proto library needed).
+ *
+ * This adapter provides:
+ *   - Full coverage when a brain transcript exists (authoritative source).
+ *   - Partial coverage (user prompts only) from history.jsonl as fallback.
+ *   - Best-effort raw-string extraction from .pb files when no other source exists.
+ *
+ * watchPath (from provider.v1.json):
+ *   ~/.gemini/antigravity-cli/history.jsonl
+ *   ~/.gemini/antigravity-cli/brain/{uuid}/.system_generated/logs/transcript*.jsonl
+ *   ~/.gemini/antigravity-cli/conversations/{uuid}.pb
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'antigravity-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    /**
+     * 'full' — brain transcript was available and parsed.
+     * 'partial' — only history.jsonl user-prompts are available.
+     * 'best-effort' — .pb file bytes were used for raw text extraction.
+     */
+    nativeHistoryCoverage: 'full' | 'partial' | 'best-effort';
+    workspace?: string;
+    partialReason?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'antigravity-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full' | 'partial' | 'best-effort';
+    partialReason?: string;
+}
+/**
+ * Read a single Antigravity CLI session by its source file path.
+ *
+ * `sessionPath` is the absolute path to one of:
+ *   - A brain transcript JSONL: ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
+ *   - The shared history.jsonl: ~/.gemini/antigravity-cli/history.jsonl
+ *   - A conversation protobuf: ~/.gemini/antigravity-cli/conversations/<uuid>.pb
+ *
+ * The session UUID is inferred from the directory name (brain), filename (pb), or
+ * must be provided explicitly via `sessionId` for history.jsonl paths.
+ *
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string, sessionId?: string, workspace?: string): Promise<NativeHistorySession | null>;
+/**
+ * List all Antigravity CLI sessions found across all watchPath locations.
+ *
+ * Priority:
+ *   1. Brain transcript sessions (full coverage) — preferred source.
+ *   2. History JSONL entries without a brain transcript (partial coverage).
+ *   3. .pb conversation files without any other source (best-effort).
+ *
+ * Returns summary metadata sorted by most recently updated first.
+ */
+export declare function listSessions(_watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/claude-cli-transcript.d.ts

@@ -0,0 +1,70 @@
+/**
+ * claude-cli-transcript — Daemon-side built-in native history adapter for claude-cli.
+ *
+ * Reads Claude Code JSONL transcript files directly without shelling out to a JS override.
+ * The transcript format is one JSON object per line, where each line has:
+ *   - type: 'user' | 'assistant'
+ *   - message: { content: string | ContentBlock[] }
+ *   - timestamp: number (ms epoch) | string (ISO)
+ *   - sessionId?: string
+ *   - cwd?: string
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'claude-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'claude-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full';
+}
+/**
+ * Read a single Claude Code session by its transcript file path.
+ *
+ * `sessionPath` is the absolute path to a `<uuid>.jsonl` file.
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string): Promise<NativeHistorySession | null>;
+/**
+ * List all Claude Code sessions under the given glob-style watchPath base dir.
+ *
+ * `watchPath` is the pattern from provider.v1.json (`~/.claude/projects/**\/*.jsonl`).
+ * This implementation expands the home directory and scans `~/.claude/projects/`
+ * recursively, collecting all `.jsonl` files.
+ *
+ * Returns summary metadata for each session (no full message reads on this hot path;
+ * each file is opened only for lightweight scanning).
+ */
+export declare function listSessions(watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/codex-cli-transcript.d.ts

@@ -0,0 +1,73 @@
+/**
+ * codex-cli-transcript — Daemon-side built-in native history adapter for codex-cli.
+ *
+ * Reads Codex CLI rollout JSONL session files directly without shelling out to a JS override.
+ * Files are stored at ~/.codex/sessions/<uuid>[-<slug>].jsonl.
+ *
+ * Format — each line is a JSON object of one of these types:
+ *   { type: 'session_meta', timestamp: number, payload: { id: string, cwd: string, ... } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'message', role: 'user'|'assistant', content: ... } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'function_call' | 'custom_tool_call', name?: string, arguments?: string, input?: unknown } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'function_call_output' | 'custom_tool_call_output', output?: string, result?: string } }
+ *
+ * watchPath (from provider.v1.json): ~/.codex/sessions
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'codex-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'codex-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full';
+}
+/**
+ * Read a single Codex CLI session by its JSONL file path.
+ *
+ * `sessionPath` is the absolute path to a `<uuid>[-<slug>].jsonl` file
+ * under ~/.codex/sessions/.
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string): Promise<NativeHistorySession | null>;
+/**
+ * List all Codex CLI sessions under the given watchPath base dir.
+ *
+ * `watchPath` is the value from provider.v1.json (`~/.codex/sessions`).
+ * Expands the home directory and scans the directory recursively,
+ * collecting all `.jsonl` files.
+ *
+ * Returns summary metadata for each session, sorted by most recently updated first.
+ */
+export declare function listSessions(watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * native-history — Daemon-side built-in adapters for CLI provider native history.
+ *
+ * Each adapter reads conversation history directly from the CLI tool's on-disk
+ * storage without shelling out to a provider JS override script.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export { readSession as readClaudeCliSession, listSessions as listClaudeCliSessions, } from './claude-cli-transcript.js';
+export { readSession as readCodexCliSession, listSessions as listCodexCliSessions, } from './codex-cli-transcript.js';
+export { readSession as readAntigravityCliSession, listSessions as listAntigravityCliSessions, } from './antigravity-cli-transcript.js';

package/dist/providers/provider-loader.d.ts

@@ -58,7 +58,9 @@ export declare class ProviderLoader {
     /** Inject VersionArchive so resolve() can auto-detect installed versions */
     setVersionArchive(archive: VersionArchive): void;
     private static readonly GITHUB_TARBALL_URL;
+    private static readonly REGISTRY_BASE_URL;
     private static readonly META_FILE;
+    private static readonly REGISTRY_META_FILE;
     private static readonly REPO_PROVIDER_DIRNAME;
     private static readonly SIBLING_MARKER_FILE;
     private static readonly SIBLING_ENV_VAR;
@@ -295,6 +297,22 @@ export declare class ProviderLoader {
     *
     * @returns Whether an update occurred
     */
+    /**
+     * Sync providers from the ADHDev registry (registry.adhf.dev).
+     *
+     * Downloads only providers whose server checksum differs from the locally
+     * cached checksum. Falls back gracefully to the GitHub tarball path if the
+     * registry is unreachable or returns an unexpected response.
+     *
+     * Returns `{ updated: true }` when at least one provider file changed on disk,
+     * `{ updated: false }` when everything is already current, or
+     * `{ updated: false, error }` when the registry couldn't be reached and we
+     * should proceed to the GitHub tarball fallback.
+     */
+    fetchFromRegistry(): Promise<{
+        updated: boolean;
+        error?: string;
+    }>;
     fetchLatest(): Promise<{
         updated: boolean;
         error?: string;
@@ -305,7 +323,7 @@ export declare class ProviderLoader {
     private copyDirRecursive;
     /** .meta.json save */
     private writeMeta;
-    /** Count provider files (provider.js or provider.json) */
+    /** Count provider files (provider.v1.json or provider.json — at most one per dir). */
     private countProviders;
     /**
     * Get public settings schema for a provider (for dashboard UI rendering)

package/dist/providers/sdk/v1/builders/acp/detect-status.d.ts

@@ -0,0 +1,68 @@
+/**
+ * buildDetectStatusFromAcp
+ *
+ * Turns a declarative `acp/session-protocol@1` block into a runtime
+ * `(input: AcpStatusInput) => 'idle' | 'generating' | 'waiting_approval' | null`
+ * function.
+ *
+ * Dispatch order:
+ *   1. Not connected → null (no information available).
+ *   2. Error patterns — checked first; first match returns the declared verdict.
+ *   3. Generating pattern — `generating`.
+ *   4. Idle pattern — `idle`.
+ *   5. Default: `null` (no change — caller preserves last known status).
+ *
+ * All regex patterns are compiled once at builder time so the returned
+ * detector function is allocation-free on the hot path.
+ */
+interface AcpRegexPatternSpec {
+    regex: string;
+    flags?: string;
+    description?: string;
+}
+interface AcpErrorPatternSpec extends AcpRegexPatternSpec {
+    verdict: 'idle' | 'generating' | 'waiting_approval';
+}
+export interface AcpSessionSpec {
+    $schema?: 'adhdev:acp/session-protocol@1';
+    /** Pattern that matches a line emitted when the agent is idle/ready. */
+    idlePattern?: AcpRegexPatternSpec;
+    /** Pattern that matches a line emitted while the agent is actively working. */
+    generatingPattern?: AcpRegexPatternSpec;
+    /**
+     * Error/edge-case patterns. Checked in order; first match returns the
+     * declared verdict. Useful for approval prompts, fatal errors, etc.
+     */
+    errorPatterns?: AcpErrorPatternSpec[];
+    /** Wire format; informational only at the builder level — regex matching
+     *  is identical regardless of promptStyle. */
+    promptStyle?: 'json-rpc' | 'plain-text' | 'mcp';
+    /** Message delimiter used to split incoming bytes (default: newline). */
+    messageDelimiter?: string;
+}
+export interface AcpStatusInput {
+    /** The most recently received line from the stdio stream. */
+    lastLine: string;
+    /**
+     * A sliding window of recent output lines (newest last).
+     * Builders may check these when a single line is not enough for context.
+     */
+    recentLines: string[];
+    /** Whether the ACP process is currently connected and running. */
+    isConnected: boolean;
+}
+export type AcpDetectedStatus = 'idle' | 'generating' | 'waiting_approval' | null;
+interface CompiledAcpSpec {
+    idle: RegExp | null;
+    generating: RegExp | null;
+    errors: Array<{
+        re: RegExp;
+        verdict: AcpDetectedStatus;
+    }>;
+}
+declare function compileSpec(spec: AcpSessionSpec): CompiledAcpSpec;
+export declare function buildDetectStatusFromAcp(spec: AcpSessionSpec): (input: AcpStatusInput) => AcpDetectedStatus;
+export declare const __internal: {
+    compileSpec: typeof compileSpec;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/detect-status.d.ts

@@ -0,0 +1,85 @@
+/**
+ * buildDetectStatusFromTui
+ *
+ * Turns a manifest's declarative TUI block into a runtime
+ * `(input: CliStatusInput) => CliStatus | null` function.
+ *
+ * Inputs handled (all optional except spinner):
+ *   - tui/spinner@1          → contributes `generating`
+ *   - tui/settled-prompt@1   → contributes `idle`
+ *   - tui/modal@1            → contributes `waiting_approval`
+ *
+ * Dispatch order (sprint-2026-06 contract):
+ *   1. Active generation cues win over idle prompt — checked first.
+ *      Reason: codex/claude keep model footer visible during `Working` and
+ *      `hasReadyPrompt` falsely fired idle. Audit §4.2 introduces
+ *      `tui/cue-ordering` as the named primitive for this rule.
+ *   2. Modal cue (if present) is checked next — `waiting_approval`.
+ *   3. Settled-prompt cue — `idle`.
+ *   4. Default: `null` (no change).
+ */
+import type { CliStatusInput, CliDetectStatusFn } from '../../types/cli/index.js';
+import { type VisibleRegionSpec } from './visible-region.js';
+interface RegexLikeSpec {
+    regex: string;
+    flags?: string;
+}
+interface SpinnerPatternSpec extends RegexLikeSpec {
+    description?: string;
+}
+interface SpinnerSpec {
+    $schema: 'adhdev:tui/spinner@1';
+    patterns: SpinnerPatternSpec[];
+    scope?: 'live-frame-tail' | 'whole-screen' | 'recent-buffer';
+    scopeWindowLines?: number;
+}
+interface SettledPromptFooterSpec {
+    pattern: string;
+    kind?: 'substring' | 'regex';
+    flags?: string;
+}
+interface SettledPromptSpec {
+    $schema: 'adhdev:tui/settled-prompt@1';
+    regex: string;
+    flags?: string;
+    withFooter?: SettledPromptFooterSpec[];
+    scope?: 'last-n-lines' | 'whole-screen';
+    scopeWindowLines?: number;
+}
+interface ModalSpec {
+    $schema: 'adhdev:tui/modal@1';
+    questionPattern: string;
+    questionFlags?: string;
+    questionVariants?: Array<{
+        regex: string;
+        flags?: string;
+        label?: string;
+    }>;
+    buttonPattern: string;
+    buttonFlags?: string;
+}
+export type DispatchGroup = 'spinner' | 'modal' | 'settled-prompt' | 'cue-ordering' | 'error-detection' | 'approval-stitching';
+export interface DispatchOrderSpec {
+    $schema: 'adhdev:tui/dispatch-order@1';
+    order: DispatchGroup[];
+    onNoMatch?: 'idle' | 'unknown' | 'preserve-last';
+}
+export interface DetectStatusTuiSpec {
+    spinner?: SpinnerSpec;
+    settledPrompt?: SettledPromptSpec;
+    modal?: ModalSpec;
+    dispatchOrder?: DispatchOrderSpec;
+    visibleRegion?: VisibleRegionSpec;
+}
+declare function scopeText(input: CliStatusInput, scope: SpinnerSpec['scope'] | SettledPromptSpec['scope'], windowLines: number | undefined): string;
+declare function spinnerMatches(spec: SpinnerSpec, input: CliStatusInput): boolean;
+declare function settledPromptMatches(spec: SettledPromptSpec, input: CliStatusInput): boolean;
+declare function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean;
+export declare function buildDetectStatusFromTui(spec: DetectStatusTuiSpec): CliDetectStatusFn;
+export declare const __internal: {
+    scopeText: typeof scopeText;
+    spinnerMatches: typeof spinnerMatches;
+    settledPromptMatches: typeof settledPromptMatches;
+    modalMatches: typeof modalMatches;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/parse-approval-squash.d.ts

@@ -0,0 +1,59 @@
+/**
+ * buildParseApprovalFromSquash
+ *
+ * Companion to buildParseApprovalFromTui. Handles the squashed-modal case:
+ * the terminal has re-flowed the approval frame so the rendered text is a
+ * single run of lowercase-alnum bytes (e.g. `doyoutrustthecontentsofthisdirectory…1yescontinue2noquit`).
+ *
+ * Author declares:
+ *   - `cues`        — compact substrings/regexes that identify the modal
+ *   - `footers`     — optional compact substrings that must also be present
+ *   - `buttonRules` — compact→labels mappings used to recover button labels
+ *
+ * Returns the same shape as buildParseApprovalFromTui — a CliApprovalModal
+ * (message + buttons) or null when no rule matches. Caller composes the two
+ * builders: try the regular modal first, then fall back to squash. Codex
+ * needs both because at narrow widths the terminal renders the squash form,
+ * and at wider widths it renders the regular framed form.
+ */
+import type { CliApprovalInput, CliParseApprovalFn } from '../../types/cli/index.js';
+interface SquashCueSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+    label?: string;
+    messageWhenMatched?: string;
+}
+interface SquashFooterSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+}
+interface SquashButtonRuleSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+    labels: string[];
+}
+export interface ApprovalSquashSpec {
+    $schema: 'adhdev:tui/approval-squash@1';
+    cues: SquashCueSpec[];
+    footers?: SquashFooterSpec[];
+    buttonRules: SquashButtonRuleSpec[];
+    scope?: 'tail-window' | 'whole-screen';
+    tailWindowLines?: number;
+}
+/**
+ * The canonical normalisation. Identical to codex-cli's `compactText`:
+ * lowercase, then strip everything that is not a-z or 0-9.
+ *
+ * Exported for tests and for the (rare) provider that wants to compose this
+ * with extra normalisation steps.
+ */
+export declare function compactText(value: string): string;
+declare function matchSubstringOrRegex(needle: string, kind: 'substring' | 'regex' | undefined, haystack: string): boolean;
+declare function scopeText(spec: ApprovalSquashSpec, input: CliApprovalInput): string;
+export declare function buildParseApprovalFromSquash(spec: ApprovalSquashSpec): CliParseApprovalFn;
+export declare const __internal: {
+    compactText: typeof compactText;
+    matchSubstringOrRegex: typeof matchSubstringOrRegex;
+    scopeText: typeof scopeText;
+};
+export {};