@giovannijecha/jecode 0.3.2 → 0.4.0

package/dist/settings-command.js

@@ -1,10 +1,11 @@
-// The persistent settings hub. Every interaction uses the shared dock picker
-// and field contracts; this module owns choices and persistence, not drawing.
-import { modelsCommand, providersCommand } from "./provider-commands.js";
-import { credentialsCommand } from "./credential-commands.js";
-import { EFFORTS, readSettings, settingsLabel, updateSettings } from "./settings.js";
+// The persistent settings hub. Provider access and model selection reuse the
+// same command flows exposed directly through /providers and /models.
+import { saveCommandSettings } from "./command-settings.js";
+import { modelsCommand } from "./model-command.js";
 import { providerFailure } from "./provider-errors.js";
-import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
+import { providerLabel } from "./provider-label.js";
+import { providersCommand } from "./provider-commands.js";
+import { EFFORTS } from "./settings.js";
 import { of } from "./tui/editor.js";
 import { heading } from "./tui/picker.js";
 /** A focused path to the same saved reasoning default exposed by /settings. */
@@ -22,7 +23,7 @@ export async function settingsCommand(session, host) {
     while (true) {
         const values = settingsValues(session);
         const items = settingsItems(values);
-        const index = await choose(settingsPicker(values, session.palette, selected));
+        const index = await choose(settingsPicker(values, selected));
         if (index === undefined)
             return;
         const action = items[index]?.action;
@@ -30,14 +31,8 @@ export async function settingsCommand(session, host) {
             return;
         selected = index;
         switch (action) {
-            case "provider":
-                await providerSetting(session, host);
-                break;
-            case "ollamaConnection":
-                await ollamaConnectionSetting(session, host, (patch) => persist(host, patch));
-                break;
             case "model":
-                await modelSetting(session, host);
+                await modelsCommand(session, host, { announce: false });
                 break;
             case "effort":
                 await effortSetting(session, host);
@@ -51,45 +46,43 @@ export async function settingsCommand(session, host) {
             case "reducedMotion":
                 await motionSetting(session, host);
                 break;
-            case "credentials":
-                await credentialsCommand(session, host);
+            case "providers":
+                await providersCommand(session, host);
                 break;
         }
     }
 }
-export function settingsPicker(values, pal, index = 0, store = settingsLabel()) {
+export function settingsPicker(values, index = 0) {
     return {
-        title: heading("settings", store, pal),
-        description: "Changes apply now · flags and environment win at launch",
+        title: [],
         options: settingsItems(values).map((item) => item.option),
         index,
     };
 }
 function settingsItems(values) {
     return [
-        { action: "provider", option: { label: "provider", hint: values.provider } },
-        ...(values.ollamaConnection === undefined
-            ? []
-            : [{
-                    action: "ollamaConnection",
-                    option: { label: "ollama connection", hint: values.ollamaConnection },
-                }]),
-        { action: "model", option: { label: "model", hint: values.model || "choose a model" } },
-        { action: "effort", option: { label: "effort", hint: values.effort } },
+        {
+            action: "model",
+            option: {
+                label: "model",
+                value: `${providerLabel(values.provider)} · ${values.model || "choose a model"}`,
+            },
+        },
+        { action: "effort", option: { label: "effort", value: values.effort } },
         ...(values.maxTokens === undefined
             ? []
             : [{
                     action: "maxTokens",
-                    option: { label: "max output tokens", hint: String(values.maxTokens) },
+                    option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
-        { action: "maxSteps", option: { label: "max tool steps", hint: String(values.maxSteps) } },
+        { action: "maxSteps", option: { label: "max tool steps", value: String(values.maxSteps) } },
         {
             action: "reducedMotion",
-            option: { label: "reduced motion", hint: values.reducedMotion ? "on" : "off" },
+            option: { label: "reduced motion", value: values.reducedMotion ? "on" : "off" },
         },
         {
-            action: "credentials",
-            option: { label: "authentication", hint: "manage API keys and accounts" },
+            action: "providers",
+            option: { label: "providers", hint: "manage access and connections" },
         },
     ];
 }
@@ -97,65 +90,18 @@ function settingsValues(session) {
     return {
         provider: session.provider.id,
         model: session.model,
-        ...(session.provider.id === "ollama" ? { ollamaConnection: ollamaConnectionHint() } : {}),
         effort: session.config.effort,
         ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
         maxSteps: session.config.maxSteps,
         reducedMotion: session.config.reducedMotion,
     };
 }
-async function providerSetting(session, host) {
-    const before = {
-        provider: session.provider,
-        model: session.model,
-        providerId: session.config.providerId,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    if (!(await providersCommand(session, host, { announce: false, save: false })))
-        return;
-    const current = readSettings();
-    const models = { ...current.models };
-    if (session.model !== "")
-        models[session.provider.id] = session.model;
-    const patch = {
-        provider: session.provider.id,
-        models,
-        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-    };
-    if (await persist(host, patch))
-        return;
-    session.provider = before.provider;
-    session.model = before.model;
-    session.config.providerId = before.providerId;
-    session.config.model = before.configModel;
-    session.config.effort = before.effort;
-}
-async function modelSetting(session, host) {
-    const before = {
-        model: session.model,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    if (!(await modelsCommand(session, host, { announce: false, save: false })))
-        return;
-    const current = readSettings();
-    const models = { ...current.models, [session.provider.id]: session.model };
-    const patch = {
-        models,
-        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-    };
-    if (await persist(host, patch))
-        return;
-    session.model = before.model;
-    session.config.model = before.configModel;
-    session.config.effort = before.effort;
-}
 async function effortSetting(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
     const efforts = await availableEfforts(session, host);
+    throwIfAborted(host.signal);
     if (efforts === undefined)
         return;
     if (efforts.length === 0) {
@@ -168,12 +114,12 @@ async function effortSetting(session, host) {
     }
     const current = session.config.effort;
     const index = await choose({
-        title: heading("effort", "saved default", session.palette),
+        title: [],
         options: efforts.map((value) => ({ label: value })),
         index: Math.max(0, efforts.findIndex((value) => value === current)),
     });
     const value = index === undefined ? undefined : efforts[index];
-    if (value === undefined || !(await persist(host, { effort: value })))
+    if (value === undefined || !(await saveCommandSettings(host, { effort: value })))
         return;
     session.config.effort = value;
     return value;
@@ -181,11 +127,15 @@ async function effortSetting(session, host) {
 async function availableEfforts(session, host) {
     if (session.provider.efforts === undefined)
         return EFFORTS;
-    host.status?.(`Asking ${session.provider.id}`);
+    host.status?.(`Asking ${providerLabel(session.provider.id)}`);
     try {
-        return await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+        throwIfAborted(host.signal);
+        const efforts = await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+        throwIfAborted(host.signal);
+        return efforts;
     }
     catch (error) {
+        throwIfAborted(host.signal);
         host.emit({
             kind: "notice",
             text: providerFailure(session.provider, error, true),
@@ -203,12 +153,12 @@ async function motionSetting(session, host) {
         return;
     const values = [false, true];
     const index = await choose({
-        title: heading("reduced motion", "saved default", session.palette),
+        title: [],
         options: values.map((value) => ({ label: value ? "on" : "off" })),
         index: session.config.reducedMotion ? 1 : 0,
     });
     const value = index === undefined ? undefined : values[index];
-    if (value === undefined || !(await persist(host, { reducedMotion: value })))
+    if (value === undefined || !(await saveCommandSettings(host, { reducedMotion: value })))
         return;
     session.config.reducedMotion = value;
     host.refreshSettings?.();
@@ -231,23 +181,18 @@ async function numberSetting(session, host, name, label) {
         host.emit({ kind: "notice", text: `${label} must be a positive integer`, tone: "error" });
         return;
     }
-    if (!(await persist(host, { [name]: value })))
+    if (!(await saveCommandSettings(host, { [name]: value })))
         return;
     session.config[name] = value;
 }
-async function persist(host, patch) {
-    try {
-        await updateSettings(patch);
-        return true;
-    }
-    catch (error) {
-        host.emit({ kind: "notice", text: `could not save settings · ${error.message}`, tone: "error" });
-        return false;
-    }
-}
 function chooser(host) {
     if (host.choose === undefined) {
         host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
     }
     return host.choose;
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

package/dist/tui/app-workflows.js

@@ -59,11 +59,16 @@ export function appWorkflows(options) {
                 state.closeWhenIdle = true;
         }
         catch (error) {
-            feedback.show({
-                text: activity.control.signal.aborted ? "interrupted" : error.message,
-                tone: activity.control.signal.aborted ? "warn" : "error",
-                timeoutMs: activity.control.signal.aborted ? 4_200 : 6_000,
-            });
+            // Command cancellation is already visible through the dock closing and
+            // the activity ending. Keep it silent instead of replacing the footer
+            // with a redundant warning.
+            if (!activity.control.signal.aborted) {
+                feedback.show({
+                    text: error.message,
+                    tone: "error",
+                    timeoutMs: 6_000,
+                });
+            }
         }
         finally {
             options.finishActivity(activity);

package/dist/tui/app.js

@@ -26,7 +26,7 @@ const ESCAPE_MS = 25;
 export async function runApp(session, transcriptRoot, environment = {}) {
     const terminal = environment.screen ?? realScreen;
     const paint = environment.paint ?? painter();
-    const keys = decoder();
+    const keys = decoder({ ctrlBackspaceIsBs: process.env["WT_SESSION"] !== undefined });
     const transcript = transcriptRenderer();
     const workspace = await workspaceLabel(session.config.root);
     const state = appState();

package/dist/tui/components/composer.js

@@ -7,7 +7,7 @@ export function renderComposer(editor, width, maxInputRows, pal, right = "") {
     const first = Math.max(0, Math.min(laid.lines.length - room, laid.cursor.row));
     const shown = laid.lines.slice(first, first + room);
     return {
-        rows: shown.map((line, index) => row(width, [{ text: line, fg: pal.ink.bright }], index === 0 && right !== "" ? [{ text: right, fg: pal.ink.muted }] : [])),
+        rows: shown.map((line, index) => row(width, [{ text: line, fg: pal.ink.bright }], index === 0 && right !== "" ? [{ text: right, fg: pal.ink.dim }] : [])),
         cursor: { row: laid.cursor.row - first, col: laid.cursor.col },
     };
 }

package/dist/tui/components/footer.js

@@ -5,7 +5,7 @@ export function renderFooter(info, status, width, pal) {
     const right = fitSegs(status, rightLimit);
     const leftRoom = Math.max(0, width - plainLen(right) - (right.length === 0 ? 0 : 1));
     const left = identity(info, leftRoom);
-    return [row(width, left === "" ? [] : [{ text: left, fg: pal.ink.muted }], right)];
+    return [row(width, left === "" ? [] : [{ text: left, fg: pal.ink.dim }], right)];
 }
 function identity(info, cols) {
     if (cols <= 0)

package/dist/tui/components/menu.js

@@ -16,28 +16,40 @@ export function menuWindow(length, selected, visible) {
     return { first, last: Math.min(count, first + room) };
 }
 function renderEntry(entry, labelWidth, width, pal) {
-    // Colour terminals use one quiet selection band and keep every label on the
-    // composer's content edge. Monochrome has no band, so it alone reserves a
-    // fixed arrow column to keep selection visible without shifting peer rows.
+    // Colour terminals spend focus on the active label instead of painting a
+    // full-width band. Monochrome has no colour, so it alone reserves a fixed
+    // arrow column to keep selection visible without shifting peer rows.
     const monochrome = !hasColor();
     const selectedMark = monochrome ? (entry.selected ? "→ " : "  ") : "";
-    const fg = entry.selected ? pal.ink.bright : pal.ink.fg;
+    const fg = entry.selected ? pal.focus : pal.ink.fg;
     const primary = [
-        { text: selectedMark, fg: entry.selected ? pal.accent : fg },
-        { text: entry.label, fg },
+        { text: selectedMark, fg },
+        { text: entry.label, fg, bold: entry.selected || undefined },
     ];
     if (width > 40 && entry.description !== undefined) {
         const gap = Math.max(2, labelWidth - primaryWidth(entry));
-        primary.push({ text: `${" ".repeat(gap)}${entry.description}`, fg: entry.selected ? pal.ink.fg : pal.ink.muted });
+        primary.push({
+            text: `${" ".repeat(gap)}${entry.description}`,
+            fg: entry.selected ? pal.ink.bright : pal.ink.muted,
+        });
     }
-    const right = width > 40 && entry.hint !== undefined
-        ? [{
-                text: elide(entry.hint, Math.max(1, Math.floor(width / 4))),
-                fg: entry.selected ? pal.ink.fg : pal.ink.muted,
-            }]
-        : [];
-    const ground = entry.selected && !monochrome ? pal.surface.inset : undefined;
-    return row(width, primary, right, ground);
+    const value = entry.value === undefined
+        ? undefined
+        : entry.selected && entry.adjustable === true
+            ? `‹ ${entry.value} ›`
+            : entry.value;
+    const summary = [entry.hint, value]
+        .filter((part) => part !== undefined)
+        .join(" · ");
+    const rightColor = entry.selected ? pal.focus : pal.ink.muted;
+    const right = summary === "" || (width <= 40 && entry.value === undefined)
+        ? []
+        : [{
+                text: elide(summary, Math.max(1, Math.floor(entry.value === undefined ? width / 4 : width * 0.45))),
+                fg: rightColor,
+                bold: entry.selected || undefined,
+            }];
+    return row(width, primary, right);
 }
 function primaryWidth(entry) {
     return plainLen([{ text: entry.label }]);

package/dist/tui/components/messages.js

@@ -46,8 +46,8 @@ export function renderReasoning(block, width, pal) {
                 fg: pal.ink.bright,
                 bold: true,
             },
-        ], action === undefined ? [] : [{ text: action, fg: pal.ink.muted }], undefined, PAD),
-        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.muted, italic: true })), [], undefined, PAD)),
+        ], action === undefined ? [] : [{ text: action, fg: pal.ink.dim }], undefined, PAD),
+        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })), [], undefined, PAD)),
     ];
 }
 export function reasoningPreviewSource(text, width) {

package/dist/tui/components/prompt.js

@@ -7,10 +7,10 @@ export const PROMPT_WIDTH = textWidth(MARK);
 export function promptLine(text, cursor, width, pal, options = {}) {
     const right = options.right === undefined || options.right === ""
         ? []
-        : [{ text: options.right, fg: pal.ink.muted }];
+        : [{ text: options.right, fg: pal.ink.dim }];
     const laid = layout(text, cursor, width, options);
     const content = laid.visible === "" && options.placeholder !== undefined
-        ? { text: options.placeholder, fg: pal.ink.muted }
+        ? { text: options.placeholder, fg: pal.ink.dim }
         : { text: laid.visible, fg: pal.ink.bright };
     return {
         row: row(width, [{ text: MARK, fg: pal.accent }, content], right),

package/dist/tui/components/status.js

@@ -6,7 +6,7 @@ export function renderStatus(info, pal) {
     if (urgent !== undefined)
         return withUnseen(feedbackSegments(urgent, pal), info.unseen, pal);
     if (info.status !== undefined) {
-        return withUnseen([{ text: "esc to interrupt", fg: pal.ink.muted }], info.unseen, pal);
+        return withUnseen([{ text: "esc to interrupt", fg: pal.ink.dim }], info.unseen, pal);
     }
     if (info.feedback !== undefined) {
         return withUnseen(feedbackSegments(info.feedback, pal), info.unseen, pal);
@@ -30,7 +30,7 @@ function feedbackSegments(feedback, pal) {
 function withUnseen(status, unseen, pal) {
     return unseen === 0
         ? status
-        : [...status, { text: " · ", fg: pal.ink.muted }, ...unseenSegments(unseen, pal)];
+        : [...status, { text: " · ", fg: pal.ink.dim }, ...unseenSegments(unseen, pal)];
 }
 function unseenSegments(unseen, pal) {
     return [{ text: `${unseen} new ↓`, fg: pal.accent, bold: true }];

package/dist/tui/components/tool.js

@@ -11,7 +11,7 @@ export function renderTool(block, width, pal, context = {}) {
             { text: " " },
             { text: `${stateGlyph(block, context)} `, fg: statusInk(block.tone, pal), bold: true },
             { text: block.name, fg: pal.ink.bright, bold: true },
-            ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.accent }]),
+            ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.technical }]),
         ], right === "" ? [] : [{ text: right, fg: statusInk(block.tone, pal) }]),
         ...shown.map((detail) => renderDetail(detail, block.tone, width, pal)),
     ];
@@ -42,7 +42,7 @@ function renderDetail(detail, tone, width, pal) {
         return row(width, [lead, rail, { text: detail.text === "" ? " " : detail.text, fg }]);
     }
     if (detail.kind === "gap") {
-        return row(width, [lead, rail, { text: detail.text, fg: pal.ink.muted, italic: true }]);
+        return row(width, [lead, rail, { text: detail.text, fg: pal.ink.dim, italic: true }]);
     }
     const number = detail.kind === "add" ? detail.newLine : detail.oldLine;
     const prefix = `${detail.kind === "add" ? "+" : detail.kind === "del" ? "-" : " "}${String(number ?? "").padStart(3)} `;
@@ -50,7 +50,7 @@ function renderDetail(detail, tone, width, pal) {
         ? pal.ink.added
         : detail.kind === "del"
             ? pal.ink.removed
-            : pal.ink.muted;
+            : pal.ink.dim;
     return row(width, [lead, rail, { text: prefix, fg }, ...emphasized(detail.text, detail.emphasis, fg)]);
 }
 function emphasized(text, emphasis, fg) {

package/dist/tui/editor.js

@@ -43,15 +43,25 @@ export function wordLeft(state) {
     return { ...state, cursor: startOfWordBefore(state.text, state.cursor) };
 }
 export function wordRight(state) {
-    return { ...state, cursor: endOfWordAfter(state.text, state.cursor) };
+    return { ...state, cursor: startOfWordAfter(state.text, state.cursor) };
 }
 /** ctrl+w — delete the word behind the cursor. */
 export function killWord(state) {
-    const from = startOfWordBefore(state.text, state.cursor);
+    const from = startOfDeletionBefore(state.text, state.cursor);
     if (from === state.cursor)
         return state;
     return { text: state.text.slice(0, from) + state.text.slice(state.cursor), cursor: from };
 }
+/** ctrl+delete — delete the word ahead of the cursor. */
+export function killNextWord(state) {
+    const to = endOfDeletionAfter(state.text, state.cursor);
+    if (to === state.cursor)
+        return state;
+    return {
+        text: state.text.slice(0, state.cursor) + state.text.slice(to),
+        cursor: state.cursor,
+    };
+}
 /** ctrl+u — delete everything behind the cursor. */
 export function killToStart(state) {
     return { text: state.text.slice(state.cursor), cursor: 0 };
@@ -89,17 +99,54 @@ function after(text, cursor) {
 }
 function startOfWordBefore(text, cursor) {
     let i = cursor;
-    while (i > 0 && text[i - 1] === " ")
+    while (i > 0 && whitespace(text[i - 1]))
         i--;
-    while (i > 0 && text[i - 1] !== " ")
+    while (i > 0 && !whitespace(text[i - 1]))
         i--;
     return i;
 }
-function endOfWordAfter(text, cursor) {
+function startOfWordAfter(text, cursor) {
     let i = cursor;
-    while (i < text.length && text[i] === " ")
+    while (i < text.length && !whitespace(text[i]))
         i++;
-    while (i < text.length && text[i] !== " ")
+    while (i < text.length && whitespace(text[i]))
         i++;
     return i;
 }
+function startOfDeletionBefore(text, cursor) {
+    if (text[cursor - 1] === "\n")
+        return cursor - 1;
+    let i = cursor;
+    while (i > 0 && horizontalWhitespace(text[i - 1]))
+        i--;
+    if (text[i - 1] === "\n")
+        return i;
+    while (i > 0 && !whitespace(text[i - 1]))
+        i--;
+    return i;
+}
+function endOfDeletionAfter(text, cursor) {
+    if (text[cursor] === "\n")
+        return cursor + 1;
+    let i = cursor;
+    if (horizontalWhitespace(text[i])) {
+        while (i < text.length && horizontalWhitespace(text[i]))
+            i++;
+        if (text[i] === "\n")
+            return i;
+        while (i < text.length && !whitespace(text[i]))
+            i++;
+        return i;
+    }
+    while (i < text.length && !whitespace(text[i]))
+        i++;
+    while (i < text.length && horizontalWhitespace(text[i]))
+        i++;
+    return i;
+}
+function horizontalWhitespace(value) {
+    return value !== undefined && value !== "\n" && /\s/u.test(value);
+}
+function whitespace(value) {
+    return value !== undefined && /\s/u.test(value);
+}

package/dist/tui/feedback.js

@@ -61,8 +61,8 @@ export function turnBlocker(session) {
     if (blocked !== undefined) {
         return {
             text: auth.kind === "oauth"
-                ? `${providerLabel(session.provider.id)} needs ${auth.label} sign-in · /settings`
-                : `${providerLabel(session.provider.id)} needs an API key · /settings`,
+                ? `${providerLabel(session.provider.id)} needs sign-in · /providers`
+                : `${providerLabel(session.provider.id)} needs an API key · /providers`,
             tone: "warn",
         };
     }

package/dist/tui/field.js

@@ -7,7 +7,7 @@ import { row } from "../ui/render.js";
 import { promptCursor, promptLine } from "./components/prompt.js";
 export function panel(field, width, pal) {
     const { ink } = pal;
-    const head = row(width, field.title, field.right === undefined ? [] : [{ text: field.right, fg: ink.muted }]);
+    const head = row(width, field.title, field.right === undefined ? [] : [{ text: field.right, fg: ink.dim }]);
     const line = promptLine(field.editor.text, field.editor.cursor, width, pal, {
         secret: field.secret,
     }).row;

package/dist/tui/help.js

@@ -4,6 +4,9 @@ import { textWidth } from "../ui/width.js";
 const CONTROL_WIDTH = 18;
 const CONTROLS = [
     { key: "up / down", description: "move through menus or history" },
+    { key: "left / right", description: "move cursor or change a value" },
+    { key: "ctrl+left / right", description: "move cursor by word" },
+    { key: "ctrl+backspace/del", description: "delete a word" },
     { key: "enter / tab", description: "select or send · complete" },
     { key: "alt+enter", description: "insert a new line" },
     { key: "esc", description: "close UI or interrupt work" },
@@ -16,7 +19,7 @@ export function panel(width, pal, maxRows = CONTROLS.length + 1) {
     const heading = row(width, [
         { text: "help  ", fg: pal.accent, bold: true },
         { text: "keyboard controls", fg: pal.ink.fg },
-    ], [{ text: "esc close", fg: pal.ink.muted }]);
+    ], [{ text: "esc close", fg: pal.ink.dim }]);
     const controls = CONTROLS.map((control) => {
         const gap = Math.max(2, CONTROL_WIDTH - textWidth(control.key));
         return row(width, [

package/dist/tui/input.js

@@ -26,6 +26,10 @@ export function applyKey(state, key) {
             return edit.wordLeft(state);
         case "wordright":
             return edit.wordRight(state);
+        case "deletewordleft":
+            return edit.killWord(state);
+        case "deletewordright":
+            return edit.killNextWord(state);
         case "home":
             return edit.home(state);
         case "end":

package/dist/tui/keys.js

@@ -5,6 +5,7 @@
 // guessed at; and a bracketed paste arrives as a delimited run that must not be
 // interpreted key by key, or a pasted newline submits half the paste.
 const ESC = String.fromCharCode(27);
+const BS = String.fromCharCode(8);
 const DEL = String.fromCharCode(127);
 const PASTE_START = "[200~";
 const PASTE_END = "[201~";
@@ -35,10 +36,18 @@ const SEQUENCES = {
     "[7~": "home",
     "[8~": "end",
     "[3~": "delete",
+    "[3;5~": "deletewordright",
     "[5~": "pageup",
     "[6~": "pagedown",
     "[1;5C": "wordright",
     "[1;5D": "wordleft",
+    // Explicit modified-key forms used by terminals with CSI-u support.
+    "[127;5u": "deletewordleft",
+    "[8;5u": "deletewordleft",
+    // Readline-compatible Alt bindings. VS Code also sends Alt+D for
+    // Ctrl+Delete and Ctrl+W for Ctrl+Backspace in its integrated terminal.
+    d: "deletewordright",
+    [DEL]: "deletewordleft",
     "[Z": "backtab",
     // alt+enter, which arrives as an escape followed by the return itself. It is
     // how a multi-line message gets written when enter is what sends one.
@@ -48,10 +57,10 @@ const CONTROL = {
     "\r": "enter",
     "\n": "enter",
     "\t": "tab",
-    "\b": "backspace",
+    [BS]: "backspace",
     [DEL]: "backspace",
 };
-export function decoder() {
+export function decoder(options = {}) {
     let held = "";
     let pasting = false;
     let pasted = "";
@@ -121,7 +130,9 @@ export function decoder() {
                 keys.push({ name: "escape", text: "", ctrl: false });
                 continue;
             }
-            const named = CONTROL[ch];
+            const named = ch === BS && options.ctrlBackspaceIsBs === true
+                ? "deletewordleft"
+                : CONTROL[ch];
             if (named !== undefined) {
                 held = held.slice(1);
                 keys.push({ name: named, text: "", ctrl: false });

package/dist/tui/overlay.js

@@ -47,6 +47,12 @@ function handlePicker(open, key) {
         case "down":
             open.picker = picker.move(open.picker, 1);
             break;
+        case "left":
+            open.picker = picker.adjust(open.picker, -1);
+            break;
+        case "right":
+            open.picker = picker.adjust(open.picker, 1);
+            break;
         case "home":
             open.picker = picker.edge(open.picker, "home");
             break;