@oxecli/oxe 1.0.0

package/.env

@@ -0,0 +1,2 @@
+OXE_SUPABASE_URL=https://ajmhaekffqzzrdfwsxfu.supabase.co
+OXE_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFqbWhhZWtmZnF6enJkZndzeGZ1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODczMzU4MzQsImV4cCI6MjEwMjkxMTgzNH0.17sukij-R3L0kecR6x2MILZBO4M1ZZ4mkyqCU5yrVyM

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oxe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# Oxe — terminal AI coding agent
+
+A terminal-based AI coding agent. This is a **native TypeScript** implementation
+(pure Node.js, no Python required).
+
+## Install
+
+```bash
+npm install -g @oxecli/oxe
+```
+
+The `oxe` command is provided by this package's `bin`.
+
+## Usage
+
+```bash
+oxe
+```
+
+On first launch you'll be prompted for an **Oxe API key** (must start with
+`oxe_live_`), generated on your Oxe dashboard.
+
+## Interactive commands
+
+| Command | Description |
+| --- | --- |
+| `/help` | Show available commands |
+| `/resume` | List saved conversations |
+| `/resume <n>` | Resume conversation number `n` |
+| `/effort <none\|low\|high>` | Set reasoning effort |
+| `/clear` | Save current conversation and start a new one |
+| `/exit`, `/quit` | Save and exit |
+
+## Configuration
+
+Environment variables:
+
+| Variable | Description | Default |
+| --- | --- | --- |
+| `OXE_DATA_DIR` | Where sessions are stored | `~/.oxe` |
+| `OXE_BASE_URL` | Chat proxy base URL | bundled backend |
+| `OXE_MODEL_NAME` | Model to use | `deepseek-v4-flash` |
+| `OXE_REASONING_EFFORT` | Default reasoning effort | `low` |
+| `OXE_TIMEOUT` / `OXE_MAX_RETRIES` / `OXE_TEMPERATURE` | Request tuning | |
+
+Sessions and user data live under `~/.oxe/sessions`, never in `node_modules`.
+
+## Development
+
+```bash
+npm install
+npm run build      # tsc -> dist/
+npm install -g .   # link as `oxe`
+```
+
+## License
+
+MIT

package/bin/oxe.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// Oxe CLI entry. Importing dist/oxe.js triggers main().
+import("../dist/oxe.js").catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/api.js

@@ -0,0 +1,64 @@
+import { OXE_SUPABASE_URL_EXPORT as OXE_SUPABASE_URL, OXE_SUPABASE_ANON_KEY_EXPORT as OXE_SUPABASE_ANON_KEY, OXE_KEY_PREFIX, } from "./config.js";
+export async function validateOxeApiKey(apiKey) {
+    const key = apiKey.trim();
+    if (!key.startsWith(OXE_KEY_PREFIX)) {
+        return {
+            valid: false,
+            error: "Invalid API key format. Only authentic Oxe API keys (starting with 'oxe_live_') are permitted.\n" +
+                "Generate your key at: http://localhost:5173/dashboard/api-keys",
+        };
+    }
+    try {
+        const resp = await fetch(`${OXE_SUPABASE_URL}/functions/v1/validate-key`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ api_key: key }),
+            signal: AbortSignal.timeout(10000),
+        });
+        const result = (await resp.json());
+        if (result?.valid) {
+            return { valid: true, key_data: result["key_data"] || {} };
+        }
+        return {
+            valid: false,
+            error: result?.error ||
+                "Oxe API key not found in cloud database. Please verify your key on the dashboard.",
+        };
+    }
+    catch (err) {
+        const code = err?.name === "TimeoutError" ? "timeout" : "network";
+        return {
+            valid: false,
+            error: `Could not reach Oxe Cloud to verify key (${code}): ${err?.message ?? err}`,
+        };
+    }
+}
+export async function reportUsage(opts) {
+    const { user_id } = opts;
+    if (!user_id)
+        return;
+    try {
+        const payload = {
+            user_id,
+            api_key_id: opts.api_key_id,
+            model: opts.model,
+            input_tokens: opts.input_tokens,
+            output_tokens: opts.output_tokens,
+            request_count: opts.request_count ?? 1,
+        };
+        await fetch(`${OXE_SUPABASE_URL}/rest/v1/usage`, {
+            method: "POST",
+            headers: {
+                apikey: OXE_SUPABASE_ANON_KEY,
+                Authorization: `Bearer ${OXE_SUPABASE_ANON_KEY}`,
+                "Content-Type": "application/json",
+                Prefer: "return=minimal",
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(4000),
+        });
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/cli.js

@@ -0,0 +1,284 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadOrPrompt, default_reasoning_effort, max_action_chars, max_resume_history_items, } from "./config.js";
+import { InferenceEngine, estimateTokens } from "./engine.js";
+import { saveSession, loadSession, listSessions, nextSessionId, conversationLabel, COMMAND_HELP, toolOutputFailed, } from "./sessions.js";
+import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, formatToolAction, truncateEllipsis, renderPanel, } from "./ui.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function truncateLabel(s) {
+    const t = String(s || "(conversation)").trim();
+    return t.length > 60 ? t.slice(0, 57) + "..." : t;
+}
+export class CLI {
+    config;
+    inputItems = [];
+    story = [];
+    sessionId = null;
+    promptHistory = [];
+    constructor() {
+        clearScreen();
+        renderPanel("AI CODING AGENT", "Engine: Ready");
+        process.stdout.write("\n");
+        this.config = null;
+    }
+    saveSession(engine) {
+        if (!this.inputItems.length)
+            return;
+        if (this.sessionId === null)
+            this.sessionId = nextSessionId();
+        saveSession({
+            id: this.sessionId,
+            label: conversationLabel(this.inputItems),
+            updated_at: new Date().toISOString().replace(/\.\d{3}Z$/, ""),
+            input_items: this.inputItems,
+            story: this.story,
+            reasoning_effort: engine.reasoningEffort,
+        });
+    }
+    printToolEntry(started, text, status) {
+        if (started) {
+            process.stdout.write(`\x1b[2m${truncateEllipsis(String(started), max_action_chars, "text")}\x1b[0m\n`);
+        }
+        const style = status === "failed" ? "\x1b[31m" : "\x1b[32m";
+        process.stdout.write(`${style}${truncateEllipsis(String(text), max_action_chars, "text")}\x1b[0m\n`);
+    }
+    showHelp() {
+        process.stdout.write("\n");
+        for (const [cmd, desc] of COMMAND_HELP) {
+            process.stdout.write(`\x1b[1m${cmd.padEnd(18)}\x1b[0m\x1b[2m${desc}\x1b[0m\n`);
+        }
+        process.stdout.write("\n");
+    }
+    renderHistory(items, maxItems = max_resume_history_items) {
+        const outputsByCallId = new Map();
+        for (const it of items) {
+            if (it["type"] === "function_call_output" && it["call_id"]) {
+                outputsByCallId.set(it["call_id"], it["output"] ?? "");
+            }
+        }
+        const renders = [];
+        for (const it of items) {
+            const typ = it["type"] ?? it["role"];
+            if (typ === "user") {
+                if (it["compaction_summary"])
+                    continue;
+                const c = it["content"];
+                if (typeof c === "string" && c.trim()) {
+                    renders.push({ kind: "user", text: c, paste_spans: it["paste_spans"] });
+                }
+                else if (Array.isArray(c) && messageText(it).trim()) {
+                    renders.push({ kind: "user", text: messageText(it), paste_spans: it["paste_spans"] });
+                }
+            }
+            else if (typ === "message") {
+                const text = messageText(it);
+                if (text.trim())
+                    renders.push({ kind: "assistant", text, footer: it["footer"] ?? "" });
+            }
+            else if (typ === "function_call") {
+                const name = it["name"] ?? "tool";
+                const rawResult = outputsByCallId.get(it["call_id"] ?? "") ?? "";
+                const failed = toolOutputFailed(name, rawResult);
+                const argumentsJson = it["arguments"] ?? "";
+                renders.push({
+                    kind: "tool",
+                    started: formatToolAction(name, argumentsJson, "started"),
+                    text: formatToolAction(name, argumentsJson, failed ? "failed" : "ok"),
+                    status: failed ? "failed" : "ok",
+                });
+            }
+        }
+        if (renders.length > maxItems) {
+            const skipped = renders.length - maxItems;
+            process.stdout.write(`\x1b[2m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
+            renders.splice(0, renders.length - maxItems);
+        }
+        const last = renders.length - 1;
+        for (let idx = 0; idx < renders.length; idx++) {
+            const r = renders[idx];
+            const kind = r["kind"];
+            const payload = r["text"];
+            if (kind === "user") {
+                process.stdout.write(`\x1b[1m❯\x1b[0m ${userDisplayText(payload, r["paste_spans"])}\n`);
+            }
+            else if (kind === "assistant") {
+                process.stdout.write(aiMarkdown(payload) + "\n");
+                let footer = String(r["footer"] ?? "").trim();
+                if (footer) {
+                    if (!footer.startsWith("("))
+                        footer = `(${footer})`;
+                    process.stdout.write("\n" + mutedMarkdown(footer) + "\n");
+                }
+            }
+            else {
+                this.printToolEntry(r["started"], payload, r["status"] ?? "");
+            }
+            if (idx < last)
+                process.stdout.write("\n");
+        }
+    }
+    renderStory(story, maxItems = max_resume_history_items) {
+        let entries = story.filter((e) => String(e["text"] ?? "").trim());
+        if (entries.length > maxItems) {
+            const skipped = entries.length - maxItems;
+            process.stdout.write(`\x1b[2m… ${skipped} earlier message(s) omitted …\x1b[0m\n\n`);
+            entries = entries.slice(-maxItems);
+        }
+        const last = entries.length - 1;
+        for (let idx = 0; idx < entries.length; idx++) {
+            const e = entries[idx];
+            const typ = e["type"];
+            const text = e["text"] ?? "";
+            if (typ === "user") {
+                process.stdout.write(`\x1b[1m❯\x1b[0m ${userDisplayText(text, e["paste_spans"])}\n`);
+            }
+            else if (typ === "assistant") {
+                process.stdout.write(aiMarkdown(text) + "\n");
+            }
+            else if (typ === "tool") {
+                this.printToolEntry(e["started"], text, e["status"] ?? "");
+            }
+            else {
+                process.stdout.write(mutedMarkdown(text) + "\n");
+            }
+            if (idx < last)
+                process.stdout.write("\n");
+        }
+    }
+    conversationRow(rec) {
+        const sid = String(rec["id"] ?? "?");
+        const updated = String(rec["updated_at"] ?? "").slice(0, 16).replace("T", " ");
+        const label = truncateLabel(rec["label"]);
+        const items = rec["input_items"] ?? [];
+        const toks = estimateTokens(items).toLocaleString();
+        return `${sid.padStart(4)}\x1b[2m  ${updated}\x1b[0m  ${label}\x1b[2m  ${items.length} items · ${toks} tok\x1b[0m`;
+    }
+    showConversationsPlain(recs) {
+        process.stdout.write("\n");
+        renderPanel("Resume a conversation with: /resume <number>", "Conversations");
+        for (const rec of recs) {
+            process.stdout.write(this.conversationRow(rec) + "\n");
+        }
+        process.stdout.write("\n");
+    }
+    pickConversation() {
+        const recs = listSessions();
+        if (!recs.length) {
+            process.stdout.write("\n");
+            renderPanel("No saved conversations yet. Type a prompt to start one.", "Conversations");
+            return null;
+        }
+        this.showConversationsPlain(recs);
+        return null;
+    }
+    async resumeConversation(engine, num) {
+        const sid = parseInt(num, 10);
+        if (Number.isNaN(sid)) {
+            renderPanel(`Invalid conversation number: ${num}`, "Error");
+            return;
+        }
+        const rec = loadSession(sid);
+        if (!rec) {
+            renderPanel(`Conversation ${sid} not found.`, "Error");
+            return;
+        }
+        this.saveSession(engine);
+        await engine.cleanupStoredResponses();
+        this.inputItems = rec["input_items"] ?? [];
+        this.story = rec["story"] ?? [];
+        this.sessionId = sid;
+        engine.reasoningEffort = String(rec["reasoning_effort"] ?? default_reasoning_effort);
+        clearScreen();
+        renderPanel(`AI CODING AGENT  (resumed ${sid})`, "Engine: Ready");
+        process.stdout.write(`\x1b[2mResumed:\x1b[0m ${truncateLabel(rec["label"])}\n`);
+        process.stdout.write(`\x1b[2m(${this.inputItems.length} items · ${estimateTokens(this.inputItems).toLocaleString()} tokens · Effort: \x1b[1;36m${engine.reasoningEffort}\x1b[0m\x1b[2m)\x1b[0m\n\n`);
+        renderPanel("Conversation history", "Restored");
+        process.stdout.write("\n");
+        if (this.story.length)
+            this.renderStory(this.story);
+        else
+            this.renderHistory(this.inputItems);
+    }
+    async replLoop(engine) {
+        for (;;) {
+            engine.inQuery = false;
+            let rawPrompt;
+            try {
+                const [input, spans] = await askBottomPrompt("You", "❯", this.promptHistory);
+                if (!input.trim())
+                    continue;
+                this.promptHistory.push(input);
+                const lower = input.trim().toLowerCase();
+                if (lower === "/exit" || lower === "/quit") {
+                    this.saveSession(engine);
+                    await engine.cleanupStoredResponses();
+                    process.stdout.write("\nClosing terminal session. Goodbye!\n");
+                    break;
+                }
+                if (lower === "/help") {
+                    this.showHelp();
+                    continue;
+                }
+                if (lower === "/clear") {
+                    this.saveSession(engine);
+                    await engine.cleanupStoredResponses();
+                    this.inputItems = [];
+                    this.story = [];
+                    this.sessionId = null;
+                    clearScreen();
+                    renderPanel("AI CODING AGENT", "Engine: Ready");
+                    process.stdout.write("\n");
+                    continue;
+                }
+                if (lower.startsWith("/resume")) {
+                    const parts = input.trim().split(/\s+/);
+                    if (parts.length === 1) {
+                        this.pickConversation();
+                    }
+                    else {
+                        await this.resumeConversation(engine, parts[1]);
+                    }
+                    continue;
+                }
+                if (lower.startsWith("/effort")) {
+                    const parts = input.trim().split(/\s+/);
+                    const effort = parts[1]?.toLowerCase() ?? "";
+                    if (["none", "low", "high"].includes(effort)) {
+                        engine.reasoningEffort = effort;
+                        process.stdout.write(`\n\x1b[2mReasoning effort set to ${effort}.\x1b[0m\n`);
+                    }
+                    else {
+                        renderPanel("Usage: /effort none|low|high", "Error");
+                    }
+                    continue;
+                }
+                process.stdout.write(`\n\x1b[1m❯\x1b[0m ${userDisplayText(input, spans)}\n\n`);
+                await engine.executeQuery(input, this.inputItems, this.story, spans);
+                this.saveSession(engine);
+            }
+            catch (err) {
+                if (err?.message === "interrupt" || err?.message === "eof") {
+                    this.saveSession(engine);
+                    await engine.cleanupStoredResponses();
+                    process.stdout.write("\nClosing terminal session. Goodbye!\n");
+                    break;
+                }
+                throw err;
+            }
+        }
+    }
+}
+export async function main() {
+    enableAnsi();
+    const app = new CLI();
+    const config = await loadOrPrompt();
+    app.config = config;
+    const engine = new InferenceEngine(config);
+    try {
+        await app.replLoop(engine);
+    }
+    finally {
+        await engine.cleanupStoredResponses();
+        await engine.client.close();
+    }
+}