@otto-code/protocol 0.8.12 → 0.8.14

package/dist/search/text-match.js

@@ -0,0 +1,262 @@
+/**
+ * Ranked text matching shared by the app's pickers and the daemon's history
+ * search. A match is a tier plus the offset it was found at; lower is better on
+ * both, so callers sort ascending and never have to invent a scale.
+ *
+ * Typo tolerance is opt-in via `fuzzy`. The pickers leave it off — a combobox
+ * over a known list wants exact narrowing — while history search turns it on
+ * because the user is recalling a title from memory.
+ */
+/** Exact tiers, best to worst. The fuzzy tier always sorts after all of them. */
+const TIER_EXACT = 0;
+const TIER_WHOLE_WORD = 1;
+const TIER_PREFIX = 2;
+const TIER_WORD_START = 3;
+const TIER_SUBSTRING = 4;
+const TIER_SUBSEQUENCE = 5;
+const TIER_FUZZY = 6;
+function isWordBoundaryChar(ch) {
+    if (ch === undefined)
+        return true;
+    return !/[a-z0-9]/.test(ch);
+}
+function scoreSubstringMatch(query, text) {
+    let best = null;
+    let pos = 0;
+    while (pos <= text.length - query.length) {
+        const found = text.indexOf(query, pos);
+        if (found === -1)
+            break;
+        const before = found > 0 ? text[found - 1] : undefined;
+        const after = text[found + query.length];
+        const startsAtBoundary = found === 0 || isWordBoundaryChar(before);
+        const endsAtBoundary = after === undefined || isWordBoundaryChar(after);
+        let tier;
+        if (startsAtBoundary && endsAtBoundary) {
+            tier = TIER_WHOLE_WORD;
+        }
+        else if (found === 0) {
+            tier = TIER_PREFIX;
+        }
+        else if (startsAtBoundary) {
+            tier = TIER_WORD_START;
+        }
+        else {
+            tier = TIER_SUBSTRING;
+        }
+        if (!best || tier < best.tier || (tier === best.tier && found < best.offset)) {
+            best = { tier, offset: found };
+        }
+        pos = found + 1;
+    }
+    return best;
+}
+function scoreSubsequenceMatch(query, text) {
+    let queryIndex = 0;
+    let firstIndex = -1;
+    let lastIndex = -1;
+    for (let textIndex = 0; textIndex < text.length && queryIndex < query.length; textIndex += 1) {
+        if (text[textIndex] !== query[queryIndex])
+            continue;
+        if (firstIndex === -1)
+            firstIndex = textIndex;
+        lastIndex = textIndex;
+        queryIndex += 1;
+    }
+    if (queryIndex !== query.length || firstIndex === -1)
+        return null;
+    return { tier: TIER_SUBSEQUENCE, offset: firstIndex, spread: lastIndex - firstIndex + 1 };
+}
+/**
+ * Damerau-Levenshtein distance, abandoned as soon as every cell in a row is
+ * over budget. Bounding it is what keeps the fuzzy tier affordable to run
+ * against every word of every candidate.
+ */
+function boundedEditDistance(query, word, budget) {
+    if (Math.abs(query.length - word.length) > budget)
+        return null;
+    let twoRowsBack = [];
+    let previousRow = Array.from({ length: word.length + 1 }, (_, index) => index);
+    for (let queryIndex = 1; queryIndex <= query.length; queryIndex += 1) {
+        const currentRow = [queryIndex];
+        let rowBest = queryIndex;
+        for (let wordIndex = 1; wordIndex <= word.length; wordIndex += 1) {
+            const substitutionCost = query[queryIndex - 1] === word[wordIndex - 1] ? 0 : 1;
+            let cost = Math.min(currentRow[wordIndex - 1] + 1, previousRow[wordIndex] + 1, previousRow[wordIndex - 1] + substitutionCost);
+            const isTransposition = queryIndex > 1 &&
+                wordIndex > 1 &&
+                query[queryIndex - 1] === word[wordIndex - 2] &&
+                query[queryIndex - 2] === word[wordIndex - 1];
+            if (isTransposition) {
+                cost = Math.min(cost, twoRowsBack[wordIndex - 2] + 1);
+            }
+            currentRow.push(cost);
+            rowBest = Math.min(rowBest, cost);
+        }
+        if (rowBest > budget)
+            return null;
+        twoRowsBack = previousRow;
+        previousRow = currentRow;
+    }
+    const distance = previousRow[word.length];
+    return distance <= budget ? distance : null;
+}
+function transpositionDistance(query, word) {
+    return isAdjacentTransposition(query, word) ? 1 : null;
+}
+/** True when the two differ only by one swap of neighbouring characters. */
+function isAdjacentTransposition(query, word) {
+    if (query.length !== word.length)
+        return false;
+    let index = 0;
+    while (index < query.length && query[index] === word[index])
+        index += 1;
+    if (index >= query.length - 1)
+        return false;
+    if (query[index] !== word[index + 1] || query[index + 1] !== word[index])
+        return false;
+    return query.slice(index + 2) === word.slice(index + 2);
+}
+export function fuzzyPolicyForToken(token) {
+    if (token.length <= 3)
+        return null;
+    if (token.length === 4)
+        return { maxEdits: 1, transpositionsOnly: true };
+    if (token.length <= 7)
+        return { maxEdits: 1, transpositionsOnly: false };
+    return { maxEdits: 2, transpositionsOnly: false };
+}
+/**
+ * Words are what people mistype, so the fuzzy tier compares the query against
+ * each word rather than against the whole string — otherwise a long title's
+ * length difference alone would blow the budget.
+ */
+function scoreFuzzyMatch(query, text, policy) {
+    if (policy.maxEdits <= 0 || query.length <= policy.maxEdits)
+        return null;
+    let best = null;
+    const wordPattern = /[a-z0-9]+/g;
+    let word = wordPattern.exec(text);
+    while (word !== null) {
+        // Compare against the whole word and against its leading slices, so a typo
+        // in a prefix ("confug" for "configuration") still lands — the length gap
+        // to the full word would otherwise blow the budget on its own.
+        const candidates = new Set([
+            word[0],
+            word[0].slice(0, query.length),
+            word[0].slice(0, query.length + policy.maxEdits),
+        ]);
+        for (const candidate of candidates) {
+            const distance = policy.transpositionsOnly
+                ? transpositionDistance(query, candidate)
+                : boundedEditDistance(query, candidate, policy.maxEdits);
+            if (distance === null)
+                continue;
+            const score = { tier: TIER_FUZZY, offset: word.index, spread: distance };
+            if (!best || compareMatchScores(score, best) < 0) {
+                best = score;
+            }
+        }
+        word = wordPattern.exec(text);
+    }
+    return best;
+}
+export function scoreMatch(query, text, options = {}) {
+    if (!query)
+        return { tier: TIER_EXACT, offset: 0 };
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (t === q)
+        return { tier: TIER_EXACT, offset: 0 };
+    const exact = scoreSubstringMatch(q, t) ?? scoreSubsequenceMatch(q, t);
+    if (exact)
+        return exact;
+    const fuzzy = options.fuzzy;
+    return fuzzy ? scoreFuzzyMatch(q, t, fuzzy) : null;
+}
+function mergeAdjacentRanges(indices) {
+    const ranges = [];
+    for (const index of indices) {
+        const last = ranges.at(-1);
+        if (last && last.start + last.length === index) {
+            last.length += 1;
+            continue;
+        }
+        ranges.push({ start: index, length: 1 });
+    }
+    return ranges;
+}
+function wordRangeAt(text, offset) {
+    let end = offset;
+    while (end < text.length && /[a-z0-9]/.test(text[end]))
+        end += 1;
+    return { start: offset, length: Math.max(end - offset, 1) };
+}
+/**
+ * Where a score's match actually landed, so a caller can mark it. Derived from
+ * a score rather than produced alongside one: ranking touches every candidate
+ * and needs no ranges, while only the handful of rows that get rendered do.
+ *
+ * The tier decides the shape. A substring hit is one span; a subsequence hit is
+ * the scattered characters it walked; a typo hit marks the whole word, because
+ * the characters the user got wrong are not in the text to point at.
+ */
+export function matchRanges(query, text, score) {
+    if (!query)
+        return [];
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (score.tier === TIER_EXACT)
+        return [{ start: 0, length: text.length }];
+    if (score.tier === TIER_FUZZY)
+        return [wordRangeAt(t, score.offset)];
+    if (score.tier === TIER_SUBSEQUENCE) {
+        const indices = [];
+        let queryIndex = 0;
+        for (let textIndex = 0; textIndex < t.length && queryIndex < q.length; textIndex += 1) {
+            if (t[textIndex] !== q[queryIndex])
+                continue;
+            indices.push(textIndex);
+            queryIndex += 1;
+        }
+        return mergeAdjacentRanges(indices);
+    }
+    return [{ start: score.offset, length: q.length }];
+}
+export function compareMatchScores(a, b) {
+    if (a.tier !== b.tier)
+        return a.tier - b.tier;
+    if (a.offset !== b.offset)
+        return a.offset - b.offset;
+    return (a.spread ?? 0) - (b.spread ?? 0);
+}
+export function tokenizeQuery(query) {
+    return query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+}
+export function scoreTextFields(query, fields, options = {}) {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return { tier: TIER_EXACT, offset: 0, spread: 0 };
+    const aggregate = { tier: TIER_EXACT, offset: 0, spread: 0 };
+    for (const token of tokens) {
+        const fuzzy = options.typoTolerant ? fuzzyPolicyForToken(token) : null;
+        let best = null;
+        for (const field of fields) {
+            const score = scoreMatch(token, field, { fuzzy });
+            if (score && (!best || compareMatchScores(score, best) < 0)) {
+                best = score;
+            }
+        }
+        if (!best)
+            return null;
+        aggregate.tier += best.tier;
+        aggregate.offset += best.offset;
+        aggregate.spread = (aggregate.spread ?? 0) + (best.spread ?? token.length);
+    }
+    return aggregate;
+}
+//# sourceMappingURL=text-match.js.map

package/dist/suggested-tasks.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 /**
  * Otto suggested-task wire schemas: the tasks.suggested.* start and dismiss RPCs and the suggested-task payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
  */
-// A suggested task an agent surfaced via the `spawn_task` tool (Claude Desktop
+// A suggested task a chat surfaced via the `suggest_task` tool (Claude Desktop
 // parity). Renders as a chip in the parent agent's session; the user starts it
 // (new worktree / local / this session) or dismisses it. The `prompt` is
 // deliberately NOT part of this wire shape - it stays server-side and is only

package/dist/terminal-input-mode.d.ts

@@ -5,6 +5,8 @@ export interface TerminalInputModeFeedResult {
 export interface TerminalInputModeState {
     kittyKeyboardFlags: number;
     win32InputMode: boolean;
+    applicationCursorKeys?: boolean;
+    bracketedPaste?: boolean;
 }
 export declare const DEFAULT_TERMINAL_INPUT_MODE_STATE: TerminalInputModeState;
 export declare function terminalInputModeSupportsModifiedEnter(state: TerminalInputModeState): boolean;
@@ -12,6 +14,8 @@ export declare function terminalInputModeStatesEqual(left: TerminalInputModeStat
 export declare class TerminalInputModeTracker {
     private kittyKeyboardFlags;
     private win32InputMode;
+    private applicationCursorKeys;
+    private bracketedPaste;
     private readonly kittyKeyboardStack;
     private pending;
     feed(data: string): TerminalInputModeFeedResult;

package/dist/terminal-input-mode.js

@@ -1,9 +1,13 @@
 export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
     kittyKeyboardFlags: 0,
     win32InputMode: false,
+    applicationCursorKeys: false,
+    bracketedPaste: false,
 };
 const ESC = String.fromCharCode(0x1b);
+const APPLICATION_CURSOR_KEYS_MODE = 1;
 const WIN32_INPUT_MODE = 9001;
+const BRACKETED_PASTE_MODE = 2004;
 const CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[(?:([<>=?]?)([0-9;]*)u|\\?([0-9;]*)([hl]))`, "g");
 const INCOMPLETE_CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[[<>=?]?[0-9;]*$`);
 function parseFirstParam(params) {
@@ -34,12 +38,16 @@ export function terminalInputModeSupportsModifiedEnter(state) {
 }
 export function terminalInputModeStatesEqual(left, right) {
     return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
-        left.win32InputMode === right.win32InputMode);
+        left.win32InputMode === right.win32InputMode &&
+        Boolean(left.applicationCursorKeys) === Boolean(right.applicationCursorKeys) &&
+        Boolean(left.bracketedPaste) === Boolean(right.bracketedPaste));
 }
 export class TerminalInputModeTracker {
     constructor() {
         this.kittyKeyboardFlags = 0;
         this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
         this.kittyKeyboardStack = [];
         this.pending = "";
     }
@@ -80,6 +88,8 @@ export class TerminalInputModeTracker {
     reset() {
         this.kittyKeyboardFlags = 0;
         this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
         this.kittyKeyboardStack.length = 0;
         this.pending = "";
     }
@@ -87,6 +97,8 @@ export class TerminalInputModeTracker {
         return {
             kittyKeyboardFlags: this.kittyKeyboardFlags,
             win32InputMode: this.win32InputMode,
+            applicationCursorKeys: this.applicationCursorKeys,
+            bracketedPaste: this.bracketedPaste,
         };
     }
     getKittyKeyboardFlags() {
@@ -103,6 +115,12 @@ export class TerminalInputModeTracker {
         if (this.win32InputMode) {
             parts.push("\x1b[?9001h");
         }
+        if (this.applicationCursorKeys) {
+            parts.push("\x1b[?1h");
+        }
+        if (this.bracketedPaste) {
+            parts.push("\x1b[?2004h");
+        }
         return parts.join("");
     }
     applyKittyKeyboardSequence(prefix, params) {
@@ -140,12 +158,23 @@ export class TerminalInputModeTracker {
     }
     applyPrivateModeSequence(params, final) {
         const modes = parsePrivateModeParams(params);
-        if (!modes.has(WIN32_INPUT_MODE)) {
-            return false;
+        let changed = false;
+        if (modes.has(WIN32_INPUT_MODE)) {
+            const previous = this.win32InputMode;
+            this.win32InputMode = final === "h";
+            changed = this.win32InputMode !== previous || changed;
+        }
+        if (modes.has(APPLICATION_CURSOR_KEYS_MODE)) {
+            const previous = this.applicationCursorKeys;
+            this.applicationCursorKeys = final === "h";
+            changed = this.applicationCursorKeys !== previous || changed;
+        }
+        if (modes.has(BRACKETED_PASTE_MODE)) {
+            const previous = this.bracketedPaste;
+            this.bracketedPaste = final === "h";
+            changed = this.bracketedPaste !== previous || changed;
         }
-        const previous = this.win32InputMode;
-        this.win32InputMode = final === "h";
-        return this.win32InputMode !== previous;
+        return changed;
     }
 }
 //# sourceMappingURL=terminal-input-mode.js.map

package/dist/terminal-key-input.js

@@ -99,6 +99,9 @@ function csiWithModifier(finalByte, input) {
     const mod = modifierParam(input);
     return mod === 1 ? `\x1b[${finalByte}` : `\x1b[1;${mod}${finalByte}`;
 }
+function ss3WithModifier(finalByte, input) {
+    return modifierParam(input) === 1 ? `\x1bO${finalByte}` : csiWithModifier(finalByte, input);
+}
 function csiTilde(base, input) {
     const mod = modifierParam(input);
     return mod === 1 ? `\x1b[${base}~` : `\x1b[${base};${mod}~`;
@@ -133,16 +136,22 @@ function encodeFunctionKey(key, input) {
             return null;
     }
 }
-function encodeNavigationKey(key, input) {
+function encodeArrowKey(finalByte, input, options) {
+    if (options.inputMode?.applicationCursorKeys) {
+        return ss3WithModifier(finalByte, input);
+    }
+    return csiWithModifier(finalByte, input);
+}
+function encodeNavigationKey(key, input, options) {
     switch (key) {
         case "ArrowUp":
-            return csiWithModifier("A", input);
+            return encodeArrowKey("A", input, options);
         case "ArrowDown":
-            return csiWithModifier("B", input);
+            return encodeArrowKey("B", input, options);
         case "ArrowRight":
-            return csiWithModifier("C", input);
+            return encodeArrowKey("C", input, options);
         case "ArrowLeft":
-            return csiWithModifier("D", input);
+            return encodeArrowKey("D", input, options);
         case "Home":
             return csiWithModifier("H", input);
         case "End":
@@ -190,7 +199,7 @@ export function encodeTerminalKeyInput(input, options = {}) {
         default:
             break;
     }
-    const nav = encodeNavigationKey(key, input);
+    const nav = encodeNavigationKey(key, input, options);
     if (nav !== null)
         return nav;
     const fn = encodeFunctionKey(key, input);

package/dist/terminal-profiles.d.ts

@@ -1,5 +1,40 @@
 import type { TerminalProfile } from "./messages.js";
+/**
+ * Marks where a typed prompt goes inside a profile's `command` or `args`. A
+ * profile carrying it accepts a prompt; one without it launches as-is.
+ *
+ * Substitution happens client-side before `create_terminal_request` is sent, so
+ * this is profile-format vocabulary rather than anything on the wire. It lives
+ * here because this module owns what a `TerminalProfile` means.
+ */
+export declare const PROMPT_SENTINEL = "{{{prompt}}}";
 export declare const DEFAULT_TERMINAL_PROFILES: readonly TerminalProfile[];
+export interface SubstitutableCommand {
+    command: string;
+    args?: string[];
+}
+export interface ResolvedCommand {
+    command: string;
+    args: string[];
+}
+/** True when the sentinel appears anywhere in `command` or an `args` entry. */
+export declare function profileTakesPrompt(profile: SubstitutableCommand): boolean;
+/** Replaces every sentinel occurrence with `prompt`, dropping prompt-only args when there is none. */
+export declare function substitutePrompt(profile: SubstitutableCommand, prompt: string): ResolvedCommand;
+/** Human-readable preview of the resolved command, for read-only display. */
+export declare function formatResolvedCommand(resolved: ResolvedCommand): string;
+export interface TerminalProfileLaunch {
+    name: string;
+    command: string;
+    args: string[];
+}
+/**
+ * What to spawn for a profile. Every launcher goes through here, so no caller
+ * can forward a raw `profile.args` still carrying the sentinel: launchers with
+ * nowhere to type (pinned targets, the workspace terminal menu) pass an empty
+ * prompt and get the bare command back.
+ */
+export declare function resolveTerminalProfileLaunch(profile: TerminalProfile, prompt: string): TerminalProfileLaunch;
 export declare function guessTerminalProfileIcon(command: string): string | undefined;
 export declare function getTerminalProfileIcon(profile: TerminalProfile): string | undefined;
 export declare function resolveTerminalProfiles(terminalProfiles: TerminalProfile[] | undefined): readonly TerminalProfile[];