@oxecli/oxe 1.0.0

package/dist/ui.js

@@ -0,0 +1,569 @@
+import * as readline from "node:readline";
+// ---------------------------------------------------------------------------
+// Terminal helpers
+// ---------------------------------------------------------------------------
+export function isWindows() {
+    return process.platform === "win32";
+}
+export function enableAnsi() {
+    // Node's tty on Windows Terminal / modern conhost supports ANSI automatically.
+    // No native SetConsoleMode available without a native module; rely on the host.
+}
+export function clearScreen() {
+    if (isWindows()) {
+        // crude but reliable clear
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    }
+    else {
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    }
+}
+export function terminalWidth() {
+    return process.stdout.columns || 80;
+}
+// ---------------------------------------------------------------------------
+// Markup tag -> ANSI
+// ---------------------------------------------------------------------------
+const TAG_MAP = {
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    italic: "\x1b[3m",
+    underline: "\x1b[4m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+};
+const RESET = "\x1b[0m";
+const MARKUP_RE = /\[(\/?)([a-z0-9 ]+)\]/gi;
+export function escapeMarkup(text) {
+    return text.replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+export function markupToAnsi(text) {
+    let open = false;
+    return text.replace(MARKUP_RE, (m, slash, tag) => {
+        const tags = tag.trim().split(/\s+/);
+        if (slash) {
+            if (open) {
+                open = false;
+                return RESET;
+            }
+            return "";
+        }
+        let codes = "";
+        let known = false;
+        for (const t of tags) {
+            const code = TAG_MAP[t];
+            if (code) {
+                codes += code;
+                known = true;
+            }
+        }
+        if (!known)
+            return m;
+        open = true;
+        return codes;
+    });
+}
+// ---------------------------------------------------------------------------
+// Lightweight markdown -> ANSI
+// ---------------------------------------------------------------------------
+export function markdownToAnsi(text) {
+    const lines = text.split("\n");
+    const out = [];
+    let inCode = false;
+    let codeBuf = [];
+    const flushCode = () => {
+        if (codeBuf.length) {
+            out.push(`\x1b[2m${codeBuf.join("\n")}\x1b[0m`);
+            codeBuf = [];
+        }
+    };
+    for (const raw of lines) {
+        const line = raw;
+        const fence = line.match(/^(`{3,})/);
+        if (fence) {
+            if (!inCode) {
+                inCode = true;
+                continue;
+            }
+            else {
+                inCode = false;
+                flushCode();
+                continue;
+            }
+        }
+        if (inCode) {
+            codeBuf.push(line);
+            continue;
+        }
+        let s = line;
+        // inline code
+        s = s.replace(/`([^`]+)`/g, (_, c) => `\x1b[2m${c}\x1b[0m`);
+        // bold
+        s = s.replace(/\*\*([^*]+)\*\*/g, "\x1b[1m$1\x1b[0m");
+        // italic
+        s = s.replace(/(^|[^\w*])\*([^*\n]+)\*(?=$|[^\w*])/g, "$1\x1b[3m$2\x1b[0m");
+        // headers
+        const h = s.match(/^(#{1,6})\s+(.*)$/);
+        if (h) {
+            s = `\x1b[1m${h[2]}\x1b[0m`;
+        }
+        // links
+        s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+        // leading list markers
+        s = s.replace(/^(\s*)([-*+]\s)/, "$1· ");
+        out.push(s);
+    }
+    flushCode();
+    return out.join("\n");
+}
+export function aiMarkdown(text) {
+    return markdownToAnsi(text);
+}
+export function mutedMarkdown(text) {
+    const dimmed = text
+        .split("\n")
+        .map((l) => `\x1b[2m${l}\x1b[0m`)
+        .join("\n");
+    return markdownToAnsi(dimmed);
+}
+// ---------------------------------------------------------------------------
+// Panel
+// ---------------------------------------------------------------------------
+export function renderPanel(content, title = "") {
+    const w = terminalWidth();
+    const innerW = Math.max(w - 4, 10);
+    const styled = markupToAnsi(content);
+    const plainLines = styled.replace(/\x1b\[[0-9;]*m/g, "").split("\n");
+    const border = "─".repeat(innerW);
+    console.log(`\x1b[90m+${border}+`);
+    if (title) {
+        const titleStr = ` ${title} `;
+        const pad = Math.max(innerW - titleStr.length, 0);
+        console.log(`\x1b[90m|${titleStr}${" ".repeat(pad)}|`);
+    }
+    const styledLines = styled.split("\n");
+    for (let i = 0; i < styledLines.length; i++) {
+        const line = styledLines[i];
+        const plain = plainLines[i] ?? "";
+        const pad = Math.max(innerW - plain.length, 0);
+        console.log(`\x1b[90m| ${line}${" ".repeat(pad)} |\x1b[0m`);
+    }
+    console.log(`\x1b[90m+${border}+\x1b[0m`);
+}
+// ---------------------------------------------------------------------------
+// Durations
+// ---------------------------------------------------------------------------
+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(" ");
+}
+export function tickDuration(seconds) {
+    return formatDuration(seconds).replace(/(\d+[a-z]*)/g, "`$1`");
+}
+// ---------------------------------------------------------------------------
+// Text helpers
+// ---------------------------------------------------------------------------
+const FENCE_MARKER_RE = /`{3,}/g;
+export function printAiChunk(chunk) {
+    process.stdout.write(markdownToAnsi(chunk) + "\n");
+    if (/^```/m.test(chunk))
+        process.stdout.write("\n");
+}
+export function safeCommitPoint(text) {
+    let idx = text.lastIndexOf("\n\n");
+    while (idx !== -1) {
+        const fenceCount = (text.slice(0, idx).match(FENCE_MARKER_RE) || []).length;
+        if (fenceCount % 2 === 0)
+            return idx;
+        idx = text.lastIndexOf("\n\n", idx - 1);
+    }
+    return 0;
+}
+export function truncateEllipsis(text, maxChars, label = "text") {
+    if (text.length > maxChars) {
+        return text.slice(0, maxChars) + ` …(${label} truncated: ${text.length.toLocaleString()} chars total)`;
+    }
+    return text;
+}
+export function displayRows(text) {
+    if (!text)
+        return 1;
+    const plain = text.replace(/`/g, "");
+    const width = Math.max(terminalWidth() || 80, 1);
+    let rows = 0;
+    const lines = plain.split("\n");
+    if (!lines.length)
+        return 1;
+    for (const line of lines) {
+        rows += Math.max(1, Math.ceil(line.length / width));
+    }
+    return rows;
+}
+// ---------------------------------------------------------------------------
+// Tool action formatter
+// ---------------------------------------------------------------------------
+export function formatToolAction(name, argumentsJson, status = "ok") {
+    let args = {};
+    try {
+        args = argumentsJson ? JSON.parse(argumentsJson) : {};
+    }
+    catch {
+        args = {};
+    }
+    const phrase = (verbOk, verbIng, verbFail, detail) => {
+        if (status === "started")
+            return `${verbIng} ${detail}`;
+        if (status === "failed")
+            return `${verbFail} ${detail}`;
+        return `${verbOk} ${detail}`;
+    };
+    const p = args["path"] ?? "";
+    switch (name) {
+        case "read_file": {
+            const start = args["start_line"];
+            const end = args["end_line"];
+            const span = start != null || end != null
+                ? `, lines ${start ?? 1} to ${end ?? "end"}`
+                : "";
+            return phrase("Read", "Reading", "Failed to read", `${p}${span}`);
+        }
+        case "write_file":
+            return phrase("Wrote", "Writing", "Failed to write", `${p} (${String(args["content"] ?? "").length} chars)`);
+        case "edit_file": {
+            const suffix = args["replace_all"] ? " (replace all)" : "";
+            return phrase("Edited", "Editing", "Failed to edit", `${p}${suffix}`);
+        }
+        case "bash": {
+            const cwd = args["cwd"];
+            const location = cwd ? ` in ${cwd}` : "";
+            const command = truncateEllipsis(String(args["command"] ?? ""), 400, "command");
+            if (status === "started")
+                return `Running command${location}: ${command}`;
+            if (status === "failed")
+                return `Command failed${location}: ${command}`;
+            return `Ran command${location}: ${command}`;
+        }
+        case "glob": {
+            const detail = String(args["pattern"] ?? "");
+            if (status === "failed")
+                return `Search failed for ${detail}`;
+            return phrase("Searched for", "Searching for", "", detail);
+        }
+        case "grep": {
+            const detail = String(args["pattern"] ?? "");
+            if (status === "failed")
+                return `Grep failed for ${detail}`;
+            return phrase("Grepped for", "Grepping for", "", detail);
+        }
+        case "load_skill": {
+            const skill = String(args["skill_name"] ?? "");
+            return phrase("Loaded skill", "Loading skill", "Failed to load skill", skill);
+        }
+        default:
+            return phrase("Invoked internal routine", "Invoking internal routine", "Internal routine failed", name);
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt editing / interactive input
+// ---------------------------------------------------------------------------
+export const PROMPT_PLACEHOLDER = "Describe a coding task, or type /help to see available commands";
+const MAX_PROMPT_DISPLAY_LINES = 12;
+const MAX_PROMPT_PASTE_CHARS = 400;
+function shouldCollapsePaste(text) {
+    return (text.split("\n").length > MAX_PROMPT_DISPLAY_LINES ||
+        text.length > MAX_PROMPT_PASTE_CHARS);
+}
+export function cursorLineCol(buffer, cursor) {
+    const before = buffer.slice(0, cursor);
+    const lines = before.split("\n");
+    return [lines.length - 1, lines[lines.length - 1].length];
+}
+function endsWithWs(s) {
+    return s.length > 0 && /[ \t\n]/.test(s[s.length - 1]);
+}
+export function splitBlocks(buffer, pasteSpans) {
+    if (!buffer)
+        return [["", "text", ""]];
+    const pts = new Set([0, buffer.length]);
+    for (const [s, e] of pasteSpans) {
+        pts.add(s);
+        pts.add(e);
+    }
+    const sorted = [...pts].sort((a, b) => a - b);
+    const segs = [];
+    const isPaste = (a, b) => pasteSpans.some(([s, e]) => s <= a && b <= e);
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i];
+        const b = sorted[i + 1];
+        if (a === b)
+            continue;
+        const text = buffer.slice(a, b);
+        if (isPaste(a, b) && shouldCollapsePaste(text)) {
+            const n = text.split("\n").length;
+            segs.push(["", "collapsed", `[Pasted text, ${n} lines]`]);
+        }
+        else {
+            segs.push(["", "text", text]);
+        }
+    }
+    return segs;
+}
+function renderBufferWithCursor(buffer, pasteSpans, prefix, cursor) {
+    const [row, col] = cursorLineCol(buffer, cursor);
+    const segs = splitBlocks(buffer, pasteSpans);
+    let display = "";
+    for (let i = 0; i < segs.length; i++) {
+        const [, kind, disp] = segs[i];
+        if (i && !endsWithWs(segs[i - 1][2]))
+            display += " ";
+        display += kind === "collapsed" ? `\x1b[1m\x1b[36m${disp}\x1b[0m` : disp;
+    }
+    const lines = display.split("\n");
+    const prefixStr = `\x1b[1m${prefix}\x1b[0m `;
+    // Reconstruct lines, prepending prefix to first line
+    const rendered = [prefixStr + (lines[0] ?? "")];
+    for (let i = 1; i < lines.length; i++)
+        rendered.push(lines[i] ?? "");
+    // Place cursor on the correct line/col (prefix+1 offset on line 0)
+    let cursorRow = row;
+    let cursorCol = col + (row === 0 ? prefix.length + 1 : 0);
+    const result = rendered.join("\n");
+    const currentLines = result.split("\n").length;
+    // Move cursor up currentLines-1 then right cursorCol
+    let cmd = "";
+    if (currentLines > 1)
+        cmd += `\x1b[${currentLines - 1}A`;
+    cmd += `\r\x1b[${cursorCol}C`;
+    return result + cmd;
+}
+export function askBottomPrompt(label = "You", prefix = "❯", history = []) {
+    return new Promise((resolve, reject) => {
+        const isTTY = process.stdin.isTTY;
+        if (!isTTY) {
+            // Non-interactive: read a line from stdin
+            const chunks = [];
+            process.stdin.setEncoding("utf-8");
+            process.stdin.on("data", (d) => chunks.push(Buffer.from(String(d))));
+            process.stdin.on("end", () => {
+                const text = Buffer.concat(chunks).toString();
+                resolve([text.trim(), []]);
+            });
+            return;
+        }
+        let buffer = "";
+        let cursor = 0;
+        let pasteSpans = [];
+        const hist = history.slice();
+        let histIdx = hist.length;
+        let draft = null;
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        let done = false;
+        const finish = (resolveVal) => {
+            if (done)
+                return;
+            done = true;
+            process.stdin.setRawMode(false);
+            process.stdout.write("\r\x1b[K");
+            process.stdout.write("\n");
+            resolve(resolveVal);
+        };
+        const repaint = () => {
+            const frame = renderBufferWithCursor(buffer, pasteSpans, prefix, cursor);
+            process.stdout.write("\r\x1b[K");
+            process.stdout.write(frame);
+        };
+        const insert = (text) => {
+            if (histIdx !== hist.length) {
+                draft = { buffer, cursor, spans: pasteSpans.slice() };
+                histIdx = hist.length;
+            }
+            buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
+            cursor += text.length;
+        };
+        const backspace = () => {
+            if (cursor <= 0)
+                return;
+            if (histIdx !== hist.length) {
+                draft = { buffer, cursor, spans: pasteSpans.slice() };
+                histIdx = hist.length;
+            }
+            // remove one grapheme before cursor
+            const before = Array.from(buffer.slice(0, cursor));
+            before.pop();
+            buffer = before.join("") + buffer.slice(cursor);
+            cursor -= 1;
+        };
+        const moveLeft = () => {
+            if (cursor > 0)
+                cursor -= 1;
+        };
+        const moveRight = () => {
+            if (cursor < buffer.length)
+                cursor += 1;
+        };
+        const moveUp = () => {
+            if (!buffer.includes("\n")) {
+                if (!hist.length)
+                    return;
+                if (histIdx === hist.length) {
+                    draft = { buffer, cursor, spans: pasteSpans.slice() };
+                }
+                if (histIdx > 0) {
+                    histIdx -= 1;
+                    buffer = hist[histIdx];
+                    cursor = buffer.length;
+                    pasteSpans = [];
+                }
+            }
+        };
+        const moveDown = () => {
+            if (!buffer.includes("\n")) {
+                if (histIdx === hist.length || !draft)
+                    return;
+                histIdx += 1;
+                if (histIdx === hist.length) {
+                    buffer = draft.buffer;
+                    cursor = draft.cursor;
+                    pasteSpans = draft.spans.slice();
+                }
+                else {
+                    buffer = hist[histIdx];
+                    cursor = buffer.length;
+                    pasteSpans = [];
+                }
+            }
+        };
+        const onKeypress = (str, key) => {
+            if (key && key.ctrl && key.name === "c") {
+                finish(["", []]);
+                reject(new Error("interrupt"));
+                return;
+            }
+            if (key && key.ctrl && (key.name === "d" || key.name === "z")) {
+                finish([buffer, []]);
+                reject(new Error("eof"));
+                return;
+            }
+            if (key && key.name === "return") {
+                if (buffer.trim()) {
+                    finish([buffer, pasteSpans]);
+                }
+                return;
+            }
+            if (key && key.name === "backspace") {
+                backspace();
+                repaint();
+                return;
+            }
+            if (key && key.name === "left") {
+                moveLeft();
+                repaint();
+                return;
+            }
+            if (key && key.name === "right") {
+                moveRight();
+                repaint();
+                return;
+            }
+            if (key && key.name === "up") {
+                moveUp();
+                repaint();
+                return;
+            }
+            if (key && key.name === "down") {
+                moveDown();
+                repaint();
+                return;
+            }
+            if (key && key.name === "tab") {
+                insert("    ");
+                repaint();
+                return;
+            }
+            if (key && key.name === "space") {
+                insert(" ");
+                repaint();
+                return;
+            }
+            if (str) {
+                // paste / multi-char sequence
+                insert(str);
+                repaint();
+            }
+        };
+        process.stdin.on("keypress", onKeypress);
+        repaint();
+    });
+}
+// ---------------------------------------------------------------------------
+// User display + message text
+// ---------------------------------------------------------------------------
+export function userDisplayText(payload, pasteSpans) {
+    if (pasteSpans && pasteSpans.length) {
+        const segs = splitBlocks(payload, pasteSpans);
+        let out = "";
+        for (let i = 0; i < segs.length; i++) {
+            const [, kind, disp] = segs[i];
+            if (i && !endsWithWs(segs[i - 1][2]))
+                out += " ";
+            out += kind === "collapsed" ? `\x1b[1m\x1b[36m${disp}\x1b[0m` : disp;
+        }
+        return out;
+    }
+    if (shouldCollapsePaste(payload)) {
+        return `\x1b[1m\x1b[36m[Pasted text, ${payload.split("\n").length} lines]\x1b[0m`;
+    }
+    return payload;
+}
+export function collapseLabelText(text, spans) {
+    if (spans && spans.length) {
+        const segs = splitBlocks(text, spans);
+        const parts = [];
+        for (const [, kind, disp] of segs) {
+            if (kind === "collapsed") {
+                parts.push(disp.replace(/\[[^\]]+\]/g, "").trim());
+            }
+            else {
+                parts.push(disp);
+            }
+        }
+        return parts.filter(Boolean).join(" ");
+    }
+    if (shouldCollapsePaste(text)) {
+        return `[Pasted text, ${text.split("\n").length} lines]`;
+    }
+    return text;
+}
+export function messageText(item) {
+    const content = item["content"];
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (part && typeof part === "object" && part["text"])
+                parts.push(part["text"]);
+        }
+        return parts.join("\n");
+    }
+    return "";
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@oxecli/oxe",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Oxe - a terminal-based AI coding agent (native TypeScript CLI).",
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "cli",
+    "terminal",
+    "coding",
+    "agent",
+    "oxe"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "oxe": "bin/oxe.js"
+  },
+  "main": "dist/oxe.js",
+  "files": [
+    "bin/",
+    "dist/",
+    "skills/",
+    ".env",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "start": "node dist/oxe.js"
+  },
+  "dependencies": {
+    "diff": "^5.2.0",
+    "openai": "^4.0.0",
+    "yaml": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}