@oxecli/oxe 1.0.52 → 1.0.53

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { loadOrPrompt, default_reasoning_effort, default_model, max_action_chars, max_resume_history_items, runtimeOsSummary, } from "./config.js";
 import { InferenceEngine, estimateTokens } from "./engine.js";
-import { saveSession, loadSession, listSessions, nextSessionId, conversationLabel, COMMAND_HELP, toolOutputFailed, } from "./sessions.js";
+import { saveSession, loadSession, listSessions, nextSessionId, conversationLabel, COMMAND_HELP, stripOrphanCalls, toolOutputFailed, } from "./sessions.js";
 import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, formatToolAction, truncateEllipsis, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, } from "./ui.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -26,7 +26,7 @@ export class CLI {
     }
     renderHeader(model = default_model) {
         const version = packageInfo.version ?? "unknown";
-        const cellWidth = 23;
+        const cellWidth = 22;
         const centeredCell = (value, render) => {
             const left = Math.max(0, Math.floor((cellWidth - value.length) / 2));
             const right = Math.max(0, cellWidth - value.length - left);
@@ -457,6 +457,7 @@ export class CLI {
                         process.stdout.write(aiMarkdown("What else can I help you with?") + "\n");
                     }
                     engine.inQuery = false;
+                    stripOrphanCalls(this.inputItems);
                     if (this.inputItems.length &&
                         this.inputItems[this.inputItems.length - 1]["role"] === "user") {
                         this.inputItems.pop();

package/dist/engine.js

@@ -307,9 +307,11 @@ export class InferenceEngine {
         }
         const usage = response?.usage;
         if (usage) {
-            stats["input"] = (stats["input"] ?? 0) + (usage?.input_tokens ?? 0);
-            const outTok = usage?.output_tokens ?? usage?.total_tokens ?? 0;
-            stats["tokens"] = (stats["tokens"] ?? 0) + outTok;
+            const inTok = usage?.input_tokens ?? 0;
+            const outTok = usage?.output_tokens ?? 0;
+            const totalTok = usage?.total_tokens ?? inTok + outTok;
+            stats["input"] = (stats["input"] ?? 0) + inTok;
+            stats["tokens"] = (stats["tokens"] ?? 0) + totalTok;
             const reasoningTok = usage?.output_tokens_details?.reasoning_tokens ?? 0;
             stats["reasoning"] = (stats["reasoning"] ?? 0) + reasoningTok;
         }
@@ -447,7 +449,18 @@ export class InferenceEngine {
             input: 0,
         };
         const queryStart = Date.now();
-        const footerText = () => `\x1b[2m(Thought for ${tickDuration(stats["thinking"])} · Worked for ${tickDuration((Date.now() - queryStart) / 1000)} · Used \x1b[22;37m${stats["tokens"].toLocaleString()}\x1b[2m tokens · Effort: \x1b[1;36m${this.reasoningEffort}\x1b[0m\x1b[2m)\x1b[0m`;
+        const footerText = () => {
+            const parts = [];
+            if (stats["thinking"] > 0) {
+                parts.push(`Thought for ${tickDuration(stats["thinking"])}`);
+            }
+            parts.push(`Worked for ${tickDuration((Date.now() - queryStart) / 1000)}`);
+            if (stats["tokens"] > 0) {
+                parts.push(`Used \x1b[22;37m${stats["tokens"].toLocaleString()}\x1b[2m tokens`);
+            }
+            parts.push(`Effort: \x1b[1;36m${this.reasoningEffort}\x1b[0m\x1b[2m`);
+            return `\x1b[2m(${parts.join(" · ")})\x1b[0m`;
+        };
         const summary = () => mutedMarkdown(footerText());
         const attachFooter = (items) => {
             const footer = footerText();

package/dist/tools.js

@@ -6,6 +6,17 @@ import { max_diff_source_chars, max_diff_lines, max_diff_context_lines, max_diff
 import { toolLoadSkill } from "./skills.js";
 export { toolLoadSkill };
 // ---------------------------------------------------------------------------
+// Path sanitization helper
+// ---------------------------------------------------------------------------
+function sanitizePath(p) {
+    if (!p)
+        return "";
+    return String(p).trim().replace(/^["']|["']$/g, "");
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// ---------------------------------------------------------------------------
 // Natural sort + diff helpers
 // ---------------------------------------------------------------------------
 export function naturalSortKey(s) {
@@ -215,7 +226,9 @@ function streamReadRange(p, start, end) {
     return [i, numbered];
 }
 export function toolReadFile(pathName, startLine = 1, endLine) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (!fs.existsSync(p))
         return `Error: file not found: ${pathName}`;
     if (!fs.statSync(p).isFile())
@@ -302,7 +315,9 @@ export function toolReadFile(pathName, startLine = 1, endLine) {
 // write_file
 // ---------------------------------------------------------------------------
 export function toolWriteFile(pathName, content) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
         return `Error: ${pathName} is a directory`;
     }
@@ -378,7 +393,9 @@ function findWsBlocks(text, needle) {
     return blocks;
 }
 export function toolEditFile(pathName, oldString, newString, replaceAll = false) {
-    const p = pathName;
+    const p = sanitizePath(pathName);
+    if (!p)
+        return "Error: path must not be empty";
     if (!fs.existsSync(p))
         return `Error: file not found: ${pathName}`;
     if (!fs.statSync(p).isFile())
@@ -467,20 +484,24 @@ export function toolBash(command, timeout = 60, cwd) {
         if (Number.isNaN(t))
             t = 60;
         t = t > 0 ? Math.min(t, max_bash_timeout_seconds) : 60;
+        const workingDir = cwd ? sanitizePath(cwd) : undefined;
+        if (workingDir && !fs.existsSync(workingDir)) {
+            return Promise.resolve(`Error: working directory not found: ${cwd}`);
+        }
         return new Promise((resolve) => {
             let child;
             try {
                 if (process.platform === "win32") {
                     child = spawn(command, {
                         shell: true,
-                        cwd: cwd || undefined,
-                        windowsHide: false,
+                        cwd: workingDir,
+                        windowsHide: true,
                     });
                 }
                 else {
                     child = spawn(command, {
                         shell: true,
-                        cwd: cwd || undefined,
+                        cwd: workingDir,
                         detached: true,
                     });
                 }
@@ -630,7 +651,7 @@ function rglobPruned(base, pattern) {
     return out;
 }
 export function toolGlob(pattern, pathName = ".", limit = 200) {
-    const base = pathName;
+    const base = sanitizePath(pathName) || ".";
     if (!fs.existsSync(base))
         return `Error: path not found: ${pathName}`;
     const lim = typeof limit === "number" ? limit : parseInt(String(limit), 10) || 200;
@@ -652,15 +673,15 @@ export function toolGlob(pattern, pathName = ".", limit = 200) {
     return result;
 }
 export function toolGrep(pattern, pathName = ".", glob = "*", limit = 200) {
-    const base = pathName;
+    const base = sanitizePath(pathName) || ".";
     if (!fs.existsSync(base))
         return `Error: path not found: ${pathName}`;
     let regex;
     try {
         regex = new RegExp(pattern, "i");
     }
-    catch (err) {
-        return `Error: invalid regex pattern: ${err}`;
+    catch {
+        regex = new RegExp(escapeRegExp(pattern), "i");
     }
     glob = glob || "*";
     const lim = typeof limit === "number" ? limit : parseInt(String(limit), 10) || 200;

package/dist/ui.js

@@ -9,8 +9,6 @@ export function enableRawStdin() {
         readline.emitKeypressEvents(process.stdin);
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
-            // Enable the kitty keyboard protocol (CSI u) so modified Enter (Shift /
-            // Ctrl+Enter) arrives as \x1b[13;<mod>u rather than a plain \r.
             process.stdout.write("\x1b[>1u");
         }
         process.stdin.resume();
@@ -136,11 +134,9 @@ const KEYWORDS = new Set([
 function highlightCodeLine(line, _lang = "") {
     if (!line)
         return "";
-    // Comments
     if (/^\s*(\/\/|#|\/\*)/.test(line)) {
         return `\x1b[2;37m${line}\x1b[0m`;
     }
-    // Tokenize words, strings, numbers
     return line.replace(/("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)|(\b\d+\.?\d*\b)|(\b[a-zA-Z_$][\w$]*\b)|(\/\/[^\n]*|#[^\n]*)/g, (m, str, num, ident, comment) => {
         if (str)
             return `\x1b[32m${str}\x1b[0m`;
@@ -153,6 +149,60 @@ function highlightCodeLine(line, _lang = "") {
         return m;
     });
 }
+function formatInlineMarkdown(text) {
+    let line = text;
+    line = line.replace(/\*\*\*([^*]+)\*\*\*/g, "\x1b[1;3m$1\x1b[0m");
+    line = line.replace(/\*\*([^*]+)\*\*/g, "\x1b[1m$1\x1b[0m");
+    line = line.replace(/(^|[^\w*])\*([^*\n]+)\*(?=$|[^\w*])/g, "$1\x1b[3m$2\x1b[0m");
+    line = line.replace(/`([^`]+)`/g, "\x1b[1;36m`$1`\x1b[0m");
+    line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "\x1b[4;36m$1\x1b[0m \x1b[2m($2)\x1b[0m");
+    return line;
+}
+// ---------------------------------------------------------------------------
+// Markdown Table Formatter
+// ---------------------------------------------------------------------------
+function formatMarkdownTable(tableLines) {
+    if (tableLines.length < 2)
+        return tableLines;
+    const parseRow = (row) => row
+        .replace(/^\||\|$/g, "")
+        .split("|")
+        .map((c) => c.trim());
+    const header = parseRow(tableLines[0]);
+    const rows = tableLines.slice(2).map(parseRow);
+    const allRows = [header, ...rows];
+    const colWidths = [];
+    for (let c = 0; c < header.length; c++) {
+        let mw = 0;
+        for (const r of allRows) {
+            if (r[c])
+                mw = Math.max(mw, plainLen(formatInlineMarkdown(r[c])));
+        }
+        colWidths.push(Math.max(mw, 3));
+    }
+    const out = [];
+    const topBorder = `\x1b[90m┌${colWidths.map((w) => "─".repeat(w + 2)).join("┬")}┐\x1b[0m`;
+    const midBorder = `\x1b[90m├${colWidths.map((w) => "─".repeat(w + 2)).join("┼")}┤\x1b[0m`;
+    const botBorder = `\x1b[90m└${colWidths.map((w) => "─".repeat(w + 2)).join("┴")}┘\x1b[0m`;
+    out.push(topBorder);
+    const headCells = header.map((h, i) => {
+        const formatted = `\x1b[1;37m${formatInlineMarkdown(h)}\x1b[0m`;
+        const pad = colWidths[i] - plainLen(formatted);
+        return ` ${formatted}${" ".repeat(Math.max(pad, 0))} `;
+    });
+    out.push(`\x1b[90m│\x1b[0m${headCells.join("\x1b[90m│\x1b[0m")}\x1b[90m│\x1b[0m`);
+    out.push(midBorder);
+    for (const r of rows) {
+        const rowCells = header.map((_, i) => {
+            const cell = r[i] ? formatInlineMarkdown(r[i]) : "";
+            const pad = colWidths[i] - plainLen(cell);
+            return ` ${cell}${" ".repeat(Math.max(pad, 0))} `;
+        });
+        out.push(`\x1b[90m│\x1b[0m${rowCells.join("\x1b[90m│\x1b[0m")}\x1b[90m│\x1b[0m`);
+    }
+    out.push(botBorder);
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Rich Markdown -> ANSI Terminal Renderer
 // ---------------------------------------------------------------------------
@@ -163,6 +213,7 @@ export function markdownToAnsi(text) {
     let inCode = false;
     let codeLang = "";
     let codeBuffer = [];
+    let tableBuffer = [];
     const flushCodeBlock = () => {
         if (!codeBuffer.length && !codeLang)
             return;
@@ -177,10 +228,18 @@ export function markdownToAnsi(text) {
         codeBuffer = [];
         codeLang = "";
     };
+    const flushTable = () => {
+        if (!tableBuffer.length)
+            return;
+        const formatted = formatMarkdownTable(tableBuffer);
+        out.push(...formatted);
+        tableBuffer = [];
+    };
     for (let i = 0; i < rawLines.length; i++) {
         const raw = rawLines[i];
         const fenceMatch = raw.match(/^(`{3,})(.*)$/);
         if (fenceMatch) {
+            flushTable();
             if (!inCode) {
                 inCode = true;
                 codeLang = fenceMatch[2].trim().toLowerCase();
@@ -197,44 +256,54 @@ export function markdownToAnsi(text) {
             codeBuffer.push(raw);
             continue;
         }
+        // Markdown Table rows
+        if (/^\s*\|.*\|\s*$/.test(raw)) {
+            tableBuffer.push(raw.trim());
+            continue;
+        }
+        else if (tableBuffer.length) {
+            flushTable();
+        }
+        // Horizontal rules
+        if (/^(\*{3,}|-{3,}|_{3,})$/.test(raw.trim())) {
+            out.push(`\x1b[90m${"─".repeat(Math.min(width, 60))}\x1b[0m`);
+            continue;
+        }
         let line = raw;
         // Headers
         const h1 = line.match(/^#\s+(.+)$/);
         if (h1) {
-            out.push(`\x1b[1;36m# ${h1[1]}\x1b[0m`);
+            out.push(`\x1b[1;36m# ${formatInlineMarkdown(h1[1])}\x1b[0m`);
             continue;
         }
         const h2 = line.match(/^##\s+(.+)$/);
         if (h2) {
-            out.push(`\x1b[1;34m## ${h2[1]}\x1b[0m`);
+            out.push(`\x1b[1;34m## ${formatInlineMarkdown(h2[1])}\x1b[0m`);
             continue;
         }
         const h3 = line.match(/^###\s+(.+)$/);
         if (h3) {
-            out.push(`\x1b[1;37m### ${h3[1]}\x1b[0m`);
+            out.push(`\x1b[1;37m### ${formatInlineMarkdown(h3[1])}\x1b[0m`);
             continue;
         }
         // Blockquote
         const bq = line.match(/^>\s*(.+)$/);
         if (bq) {
-            out.push(`\x1b[90m│\x1b[0m \x1b[3m${bq[1]}\x1b[0m`);
+            out.push(`\x1b[90m│\x1b[0m \x1b[3m${formatInlineMarkdown(bq[1])}\x1b[0m`);
             continue;
         }
         // Unordered List item
-        line = line.replace(/^(\s*)[-*+]\s+(.+)$/, "$1\x1b[36m•\x1b[0m $2");
+        line = line.replace(/^(\s*)[-*+]\s+(.+)$/, (_, indent, item) => {
+            return `${indent}\x1b[36m•\x1b[0m ${formatInlineMarkdown(item)}`;
+        });
         // Ordered List item
-        line = line.replace(/^(\s*)(\d+)\.\s+(.+)$/, "$1\x1b[36m$2.\x1b[0m $3");
-        // Inline formatting:
-        // Bold + Italic (***text*** or ___text___)
-        line = line.replace(/\*\*\*([^*]+)\*\*\*/g, "\x1b[1;3m$1\x1b[0m");
-        // Bold (**text** or __text__)
-        line = line.replace(/\*\*([^*]+)\*\*/g, "\x1b[1m$1\x1b[0m");
-        // Italic (*text* or _text_)
-        line = line.replace(/(^|[^\w*])\*([^*\n]+)\*(?=$|[^\w*])/g, "$1\x1b[3m$2\x1b[0m");
-        // Inline code (`code`)
-        line = line.replace(/`([^`]+)`/g, "\x1b[1;36m`$1`\x1b[0m");
-        // Links [text](url) -> text (url)
-        line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "\x1b[4;36m$1\x1b[0m \x1b[2m($2)\x1b[0m");
+        line = line.replace(/^(\s*)(\d+)\.\s+(.+)$/, (_, indent, num, item) => {
+            return `${indent}\x1b[36m${num}.\x1b[0m ${formatInlineMarkdown(item)}`;
+        });
+        // Inline formatting if not a list
+        if (!line.includes("\x1b[36m•\x1b[0m") && !line.includes(".\x1b[0m ")) {
+            line = formatInlineMarkdown(line);
+        }
         // Word wrap paragraph line if too long
         if (plainLen(line) > width && !line.startsWith(" ")) {
             const words = line.split(" ");
@@ -256,9 +325,9 @@ export function markdownToAnsi(text) {
             out.push(line);
         }
     }
-    if (inCode) {
+    flushTable();
+    if (inCode)
         flushCodeBlock();
-    }
     return out.join("\n");
 }
 export function aiMarkdown(text) {
@@ -286,11 +355,13 @@ function panelString(content, title = "", subtitle = "", expand = true, borderSt
     if (subtitle)
         maxLineW = Math.max(maxLineW, plainLen(subtitle) + 4);
     const termW = terminalWidth();
-    const boxW = expand ? Math.max(termW - 4, 20) : Math.min(maxLineW + 4, termW - 4);
-    const innerW = boxW - 4;
+    const boxW = expand
+        ? Math.max(termW - 4, 20)
+        : Math.min(Math.max(maxLineW + 4, 20), termW - 4);
+    const innerW = Math.max(boxW - 4, 1);
     const embed = (text, align) => {
         if (!text)
-            return "─".repeat(boxW - 2);
+            return "─".repeat(Math.max(boxW - 2, 0));
         const inner = ` ${text} `;
         const fill = Math.max(boxW - 2 - plainLen(inner), 0);
         if (align === "left") {
@@ -306,8 +377,15 @@ function panelString(content, title = "", subtitle = "", expand = true, borderSt
     for (let i = 0; i < styledLines.length; i++) {
         const line = styledLines[i];
         const plain = plainLines[i] ?? "";
-        const pad = Math.max(innerW - plain.length, 0);
-        out.push(`\x1b[${borderStyle}m│\x1b[0m ${line}${" ".repeat(pad)} \x1b[${borderStyle}m│\x1b[0m`);
+        if (plain.length > innerW) {
+            // Truncate cleanly if single line overflows max box width
+            const truncated = line.slice(0, innerW);
+            out.push(`\x1b[${borderStyle}m│\x1b[0m ${truncated} \x1b[${borderStyle}m│\x1b[0m`);
+        }
+        else {
+            const pad = Math.max(innerW - plain.length, 0);
+            out.push(`\x1b[${borderStyle}m│\x1b[0m ${line}${" ".repeat(pad)} \x1b[${borderStyle}m│\x1b[0m`);
+        }
     }
     const bottom = `╰${embed(subtitle, "center")}╯`;
     out.push(`\x1b[${borderStyle}m${bottom}\x1b[0m`);
@@ -351,19 +429,12 @@ export function renderTableString(rows, opts = {}) {
 // Durations & Text Formatting
 // ---------------------------------------------------------------------------
 export function formatDuration(seconds) {
-    const total = Math.max(0, Math.round(seconds));
-    const hours = Math.floor(total / 3600);
-    const rem = total % 3600;
-    const minutes = Math.floor(rem / 60);
-    const secs = rem % 60;
-    const parts = [];
-    if (hours)
-        parts.push(`${hours}h`);
-    if (minutes)
-        parts.push(`${minutes}min`);
-    if (secs || !parts.length)
-        parts.push(`${secs}s`);
-    return parts.join(" ");
+    const total = Math.max(0, Math.round(seconds * 10) / 10);
+    if (total < 60)
+        return `${total}s`;
+    const mins = Math.floor(total / 60);
+    const secs = Math.round(total % 60);
+    return `${mins}m ${secs}s`;
 }
 export function tickDuration(seconds) {
     return `\x1b[22;37m${formatDuration(seconds)}\x1b[2m`;
@@ -657,7 +728,6 @@ function wrapRuns(runs, width) {
 export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor) {
     const termW = terminalWidth();
     const boxW = Math.max(termW - 4, 16);
-    // Content inside border: `│ ` on left (2 chars) and ` │` on right (2 chars)
     const innerW = boxW - 4;
     const runs = [];
     runs.push({ text: prefix, style: "\x1b[1;36m" });
@@ -743,8 +813,6 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
         }
     }
     const { rows, caretRow, caretCol } = wrapRuns(runs, innerW);
-    // Math for exact box alignment:
-    // Top: `╭─ ` (3 chars) + `label` (L chars) + ` ` (1 char) + topPad + `╮` (1 char) = boxW
     const labelLen = plainLen(label);
     const topPad = Math.max(0, boxW - labelLen - 5);
     const top = `\x1b[90m╭─ \x1b[1m\x1b[36m${label}\x1b[0m\x1b[90m ${"─".repeat(topPad)}╮\x1b[0m`;
@@ -754,7 +822,6 @@ export function renderBufferWithCursor(buffer, pasteSpans, prefix, label, cursor
         const pad = Math.max(0, innerW - plain.length);
         body.push(`\x1b[90m│\x1b[0m ${l}${" ".repeat(pad)} \x1b[90m│\x1b[0m`);
     }
-    // Bottom: `╰` (1 char) + `─` * (boxW - 2) + `╯` (1 char) = boxW
     const bottom = `\x1b[90m╰${"─".repeat(Math.max(0, boxW - 2))}╯\x1b[0m`;
     const frame = [top, ...body, bottom].join("\n");
     const cursorRow = (caretRow === -1 ? 0 : caretRow) + 1;
@@ -932,6 +999,36 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
             }
             pasteSpans = adjusted.filter(([s, e]) => s < e);
         };
+        const deleteChar = () => {
+            if (cursor >= buffer.length)
+                return;
+            if (histIdx !== hist.length) {
+                draft = { buffer, cursor, spans: pasteSpans.slice() };
+                histIdx = hist.length;
+            }
+            const containing = pasteSpans.find(([s, e]) => s <= cursor && cursor < e);
+            if (containing) {
+                const [start, end] = containing;
+                buffer = buffer.slice(0, start) + buffer.slice(end);
+                const delta = start - end;
+                pasteSpans = pasteSpans
+                    .filter(([s, e]) => s !== start || e !== end)
+                    .map(([s, e]) => (s >= end ? [s + delta, e + delta] : [s, e]));
+                return;
+            }
+            buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+        };
+        const deleteWordBefore = () => {
+            if (cursor <= 0)
+                return;
+            const before = buffer.slice(0, cursor);
+            const trimmed = before.replace(/\s+$/, "");
+            const lastSpace = Math.max(trimmed.lastIndexOf(" "), trimmed.lastIndexOf("\t"), trimmed.lastIndexOf("\n"));
+            const targetPos = lastSpace === -1 ? 0 : lastSpace + 1;
+            buffer = buffer.slice(0, targetPos) + buffer.slice(cursor);
+            cursor = targetPos;
+            pasteSpans = [];
+        };
         const moveLeft = () => {
             if (cursor <= 0)
                 return;
@@ -1138,6 +1235,33 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 settle(new Error("eof"), true);
                 return;
             }
+            if (key && key.ctrl && key.name === "a") {
+                cursor = 0;
+                repaint();
+                return;
+            }
+            if (key && key.ctrl && key.name === "e") {
+                cursor = buffer.length;
+                repaint();
+                return;
+            }
+            if (key && key.ctrl && key.name === "u") {
+                buffer = "";
+                cursor = 0;
+                pasteSpans = [];
+                repaint();
+                return;
+            }
+            if (key && key.ctrl && key.name === "k") {
+                buffer = buffer.slice(0, cursor);
+                repaint();
+                return;
+            }
+            if (key && key.ctrl && key.name === "w") {
+                deleteWordBefore();
+                repaint();
+                return;
+            }
             if (isNewlineKey(key) ||
                 isModifiedEnterInput(str, key) ||
                 (pasteBurst && isSubmitEnterKey(key))) {
@@ -1156,6 +1280,21 @@ export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
                 repaint();
                 return;
             }
+            if (key && (key.name === "delete" || key.sequence === "\x1b[3~")) {
+                deleteChar();
+                repaint();
+                return;
+            }
+            if (key && (key.name === "home" || key.sequence === "\x1b[H" || key.sequence === "\x1b[1~")) {
+                cursor = 0;
+                repaint();
+                return;
+            }
+            if (key && (key.name === "end" || key.sequence === "\x1b[F" || key.sequence === "\x1b[4~")) {
+                cursor = buffer.length;
+                repaint();
+                return;
+            }
             if (key && key.name === "left") {
                 moveLeft();
                 repaint();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxecli/oxe",
-  "version": "1.0.52",
+  "version": "1.0.53",
   "publishConfig": {
     "access": "public"
   },