oakode 0.0.0-stage → 0.5.1

package/dist/tui/view.js

@@ -0,0 +1,337 @@
+import { INTERRUPTED } from "../session.js";
+import { bold, cyan, dim, gray, green, red, safeText, truncate, visible, width, wrap, yellow } from "../ui.js";
+import { MarkdownStream } from "./markdown.js";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function fmtDuration(ms) {
+    const s = ms / 1000;
+    if (s < 10)
+        return `${s.toFixed(1)}s`;
+    if (s < 60)
+        return `${Math.round(s)}s`;
+    return `${Math.floor(s / 60)}m ${String(Math.round(s % 60)).padStart(2, "0")}s`;
+}
+/** One line of live command output as shown: only the last redraw of a \r progress line, control characters visible. */
+/** A one-line summary of a read, grep, glob or ls result ("58 lines", "12 matches in 3 files"), or undefined to show it as before. */
+export function explored(name, result) {
+    const plural = (n, w) => `${n} ${w}${n === 1 ? "" : w.endsWith("ch") ? "es" : "s"}`;
+    if (name === "grep") {
+        if (/^No matches/.test(result))
+            return "no matches";
+        const m = /\[(\d+) match(?:es)? in (\d+) files?/.exec(result);
+        return m ? `${plural(Number(m[1]), "match")} in ${plural(Number(m[2]), "file")}` : undefined;
+    }
+    if (name === "read") {
+        const lines = (result.match(/^ *\d+\t/gm) ?? []).length;
+        if (!lines)
+            return undefined; // an image, an empty file or a note: shown as before
+        const files = (result.match(/^==> .* <==$/gm) ?? []).length;
+        return files > 1 ? `${plural(files, "file")}, ${plural(lines, "line")}` : plural(lines, "line");
+    }
+    if (name === "glob")
+        return /^No files match/.test(result) ? "no matches" : plural(result.split("\n").filter((l) => l.trim() && !/^[[(]/.test(l)).length, "file");
+    if (name === "ls")
+        return plural(result.split("\n").filter((l) => l.trim() && !/^[[(]/.test(l)).length, "entry").replace("entrys", "entries");
+    return undefined;
+}
+const liveLine = (l) => visible(l.includes("\r") ? l.slice(l.lastIndexOf("\r", l.length - 2) + 1).replace(/\r$/, "") : l);
+export class ChatView {
+    host;
+    stream = new MarkdownStream();
+    liveStream = [];
+    /** Text arrived since the last render: re-render once per painted frame, not once per token. */
+    streamDirty = false;
+    tools = new Map();
+    turnStart = 0;
+    label = "";
+    active = false;
+    waitingFor = "";
+    ticker;
+    lastKind = "none";
+    /** While restoring history, output is collected here and committed in one piece. */
+    sink = null;
+    /** Extra status lines shown above the spinner while a turn runs (subagents). */
+    extraLive;
+    constructor(host) {
+        this.host = host;
+    }
+    out(lines) {
+        if (this.sink)
+            this.sink.push(...lines);
+        else
+            this.host.print(lines);
+    }
+    get busy() {
+        return this.active;
+    }
+    beginTurn() {
+        this.active = true;
+        this.turnStart = Date.now();
+        this.label = "Thinking…";
+        this.ticker = setInterval(() => this.host.invalidate(), 100);
+        this.ticker.unref(); // the spinner never keeps the process alive
+        this.host.invalidate();
+    }
+    endTurn() {
+        this.finishStream();
+        this.tools.clear();
+        this.active = false;
+        clearInterval(this.ticker);
+        this.ticker = undefined;
+        this.host.invalidate();
+    }
+    gap(kind) {
+        if (this.lastKind !== "none" && (this.lastKind !== kind || kind === "user"))
+            this.out([""]);
+        this.lastKind = kind;
+    }
+    /** While a menu is open the agent is idle, waiting for the user: say so instead of animating. */
+    setWaiting(what) {
+        this.waitingFor = what;
+        this.host.invalidate();
+    }
+    /** Echo of what the user sent. */
+    user(text) {
+        this.finishStream(); // a queued message delivered mid-turn comes after the answer it followed
+        this.gap("user");
+        const cols = this.host.cols();
+        const lines = text.split("\n").flatMap((l) => wrap(l, cols - 2));
+        this.out(lines.map((l, i) => (i === 0 ? bold(cyan("› ")) : "  ") + bold(l)));
+    }
+    note(text, kind = "info") {
+        this.gap("note");
+        const style = kind === "warn" ? yellow : dim;
+        this.out(text.split("\n").flatMap((l) => wrap(l, this.host.cols())).map((l) => style(l)));
+    }
+    /** Lines printed as they are (diffs, listings), with a leading gap. */
+    block(lines) {
+        this.gap("note");
+        this.out(lines);
+    }
+    /**
+     * Draw a saved conversation with the same components as live output. Nothing is executed: tool calls and results are
+     * only displayed. `summarize` turns a tool call into the one-line description (unknown tools get a generic one).
+     */
+    replay(messages, summarize) {
+        this.sink = [];
+        let shown = 0;
+        const pending = new Map();
+        const flushPending = () => {
+            for (const [, summary] of pending)
+                this.commitTool(summary, INTERRUPTED, true, 0);
+            pending.clear();
+        };
+        try {
+            for (const m of messages) {
+                if (m.role === "tool") {
+                    const summary = pending.get(m.tool_call_id);
+                    if (summary === undefined)
+                        continue; // orphan (its call was compacted away or never saved)
+                    pending.delete(m.tool_call_id);
+                    const text = String(m.content ?? "");
+                    this.commitTool(summary, text, text === INTERRUPTED || /^Error: /.test(text), 0);
+                    shown++;
+                    continue;
+                }
+                flushPending();
+                if (m.role === "user") {
+                    const text = String(m.content ?? "");
+                    if (text.startsWith("[OAKODE notice]"))
+                        this.note(text.replace("[OAKODE notice] ", "↳ "), "info");
+                    else if (text.startsWith("[Summary of the earlier conversation"))
+                        this.note("↳ (a compaction summary stands in for earlier history here)");
+                    else
+                        this.user(text);
+                    shown++;
+                }
+                else if (m.role === "assistant") {
+                    if (m.content) {
+                        this.gap("text");
+                        const md = new MarkdownStream();
+                        md.push(safeText(String(m.content)));
+                        this.out(md.finish(this.host.cols()));
+                    }
+                    for (const c of m.tool_calls ?? []) {
+                        let args = {};
+                        try {
+                            args = JSON.parse(c.function.arguments);
+                        }
+                        catch { }
+                        let summary;
+                        try {
+                            summary = summarize(c.function.name, args);
+                        }
+                        catch { }
+                        pending.set(c.id, summary ?? `${c.function.name} ${truncate(visible(c.function.arguments), 80)}`);
+                    }
+                    shown++;
+                }
+            }
+            flushPending();
+        }
+        finally {
+            const lines = this.sink;
+            this.sink = null;
+            if (lines.length)
+                this.host.print(lines);
+        }
+        return shown;
+    }
+    // ------------------------------------------------------------------ events
+    onEvent(e) {
+        switch (e.type) {
+            case "text": {
+                if (this.stream.empty && !this.liveStream.length)
+                    this.gap("text");
+                this.label = "Writing…";
+                this.stream.push(safeText(e.delta));
+                this.streamDirty = true;
+                break;
+            }
+            case "tool_start": {
+                this.finishStream();
+                this.tools.set(e.call.id, { summary: e.summary, start: Date.now(), tail: [], out: [], partial: "" });
+                this.label = "Working…";
+                break;
+            }
+            case "tool_output": {
+                // output chunks are not tied to a call id: they belong to the tool running right now (tools run one at a time)
+                const t = [...this.tools.values()].at(-1);
+                if (t) {
+                    // raw text first, cleaned when shown: a progress bar's \r redraws keep only the last one (instead of
+                    // turning into \uFFFD marks), and a line that never ends is capped instead of growing without bound
+                    const parts = (t.partial + e.chunk.replace(/\r\n/g, "\n")).split("\n");
+                    t.partial = (parts.pop() ?? "").slice(-4096);
+                    t.out.push(...parts.map(liveLine));
+                    if (t.out.length > 400)
+                        t.out.splice(0, t.out.length - 400);
+                    t.tail = [...t.out, liveLine(t.partial)].filter((l) => l.trim()).slice(-4);
+                }
+                break;
+            }
+            case "tool_end": {
+                const t = this.tools.get(e.call.id);
+                this.tools.delete(e.call.id);
+                this.commitTool(t?.summary ?? e.call.function.name, e.result, e.isError, t ? Date.now() - t.start : 0);
+                this.label = "Thinking…";
+                break;
+            }
+            case "compacting":
+                this.finishStream();
+                this.label = "Compacting the conversation…";
+                break;
+            case "compacted":
+                this.note(`✓ Compacted: ~${e.before} → ~${e.after} tokens.${e.split ? " A long turn was split; its request is kept verbatim." : ""} The full history stays in the session file.`);
+                this.label = "Thinking…";
+                break;
+            case "notice":
+                this.finishStream();
+                this.note(e.text, "warn");
+                break;
+            case "reasoning":
+                this.label = "Reasoning…";
+                break;
+            case "usage":
+                this.label = "Thinking…";
+                break;
+        }
+        this.host.invalidate();
+    }
+    // ------------------------------------------------------------------ streaming markdown
+    budget() {
+        return Math.max(3, this.host.maxLive() - 14);
+    }
+    pullStream() {
+        this.streamDirty = false;
+        const { commit, live } = this.stream.pull(this.host.cols(), this.budget());
+        if (commit.length)
+            this.out(commit);
+        this.liveStream = live;
+    }
+    /** The assistant message (or the part of it before a tool call) is complete: commit whatever is pending. */
+    finishStream() {
+        this.streamDirty = false;
+        if (this.stream.empty && !this.liveStream.length)
+            return;
+        const rest = this.stream.finish(this.host.cols());
+        if (rest.length)
+            this.out(rest);
+        this.liveStream = [];
+    }
+    // ------------------------------------------------------------------ tools
+    commitTool(summary, result, isError, ms) {
+        this.gap("tool");
+        const cols = this.host.cols();
+        const sp = summary.indexOf(" ");
+        const name = sp < 0 ? summary : summary.slice(0, sp);
+        const rest = sp < 0 ? "" : summary.slice(sp + 1);
+        const dur = ms >= 1000 ? dim(` (${fmtDuration(ms)})`) : "";
+        const isShell = name === "$";
+        // a command's outcome belongs in its header: a failed one must not look like a success
+        let body = visible(result.replace(/\s+$/, "")).split("\n");
+        let outcome = "";
+        let failed = isError;
+        if (isShell && !isError) {
+            const last = body.at(-1) ?? "";
+            const code = /\[exit code ([^\]]+)\]/.exec(last)?.[1];
+            const stopped = /\[(timed out after [^\]]+|interrupted by user)\]/.exec(last)?.[1];
+            if (/^\[failed to start: /.test(last))
+                (outcome = red(" failed to start")), (failed = true);
+            else if (code !== undefined || stopped) {
+                const tail = last.replace(/\s*\[exit code [^\]]+\]\s*/, " ").replace(/\[(timed out after [^\]]+|interrupted by user)\]/, "").trim();
+                body = body.slice(0, -1).concat(tail ? [tail] : []);
+                if (stopped)
+                    outcome = yellow(` ${stopped}`);
+                else if (code !== "0")
+                    (outcome = red(` exit ${code}`)), (failed = true);
+                if (!body.some((l) => l.trim()))
+                    body = [dim("(no output)")];
+            }
+        }
+        const head = `${failed ? red("●") : outcome ? yellow("●") : green("●")} ${bold(name)} ${rest ? gray(visible(rest)) : ""}${outcome}${dur}`;
+        // reads and searches: what was looked at and how much, not the contents (the model has them; the transcript stays short)
+        const seen = isError ? undefined : explored(name, result);
+        if (seen !== undefined)
+            return void this.out([truncate(`${head}${dim(` (${seen})`)}`, cols)]);
+        const lines = [truncate(head, cols)];
+        const keep = isError ? 4 : isShell ? 12 : name === "edit" || name === "write" ? 1 : 4;
+        const shown = isShell || isError ? (body.length > keep ? body.slice(-keep) : body) : body.slice(0, keep);
+        const hidden = body.length - shown.length;
+        if (hidden > 0 && isShell && !isError)
+            lines.push(dim(`  … ${hidden} earlier line${hidden > 1 ? "s" : ""}`));
+        for (const l of shown)
+            lines.push("  " + (isError ? red(truncate(l, cols - 2)) : dim(truncate(l, cols - 2))));
+        if (hidden > 0 && !(isShell && !isError))
+            lines.push(dim(`  … ${hidden} more line${hidden > 1 ? "s" : ""} (sent to the model)`));
+        this.out(lines);
+    }
+    // ------------------------------------------------------------------ live area
+    /** Streaming answer, running tools and the status line. */
+    live(cols, maxRows) {
+        if (!this.active)
+            return [];
+        if (this.streamDirty)
+            this.pullStream(); // its finished lines print above this frame (Screen writes them first)
+        const out = [...this.liveStream.map((l) => truncate(l, cols))];
+        const frame = FRAMES[Math.floor(Date.now() / 100) % FRAMES.length];
+        const now = Date.now();
+        if (this.waitingFor) {
+            out.push(truncate(`${yellow("●")} ${bold("Waiting for you")} ${dim(this.waitingFor)}`, cols));
+            return out.length > maxRows ? out.slice(out.length - maxRows) : out;
+        }
+        if (this.tools.size) {
+            out.push("");
+            for (const t of this.tools.values()) {
+                out.push(truncate(`${cyan(frame)} ${bold("Running")} ${gray(t.summary)} ${dim(fmtDuration(now - t.start))}`, cols));
+                for (const l of t.tail.slice(-3))
+                    out.push(truncate(dim("    " + l), cols));
+            }
+        }
+        const extra = this.extraLive?.(cols) ?? [];
+        if (extra.length)
+            out.push("", ...extra);
+        out.push(truncate(`${cyan(frame)} ${this.label} ${dim(`(${fmtDuration(now - this.turnStart)} · esc to interrupt)`)}`, cols));
+        // keep the status line and tools; if over budget the oldest streaming lines scroll out of the live area
+        return out.length > maxRows ? out.slice(out.length - maxRows) : out;
+    }
+}
+export { width };

package/dist/ui.js

@@ -0,0 +1,105 @@
+/** Colors and small formatting helpers shared by the terminal UI. */
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+/** Colors are on for a TTY unless NO_COLOR is set; FORCE_COLOR overrides (used by tests that inspect styling). */
+const color = !process.env.NO_COLOR && (!!process.env.FORCE_COLOR || process.stdout.isTTY === true);
+const sgr = (open, close = "0") => (s) => (color ? `\x1b[${open}m${s}\x1b[${close}m` : s);
+export const dim = sgr("2", "22");
+export const bold = sgr("1", "22");
+export const italic = sgr("3", "23");
+export const underline = sgr("4", "24");
+export const strike = sgr("9", "29");
+export const red = sgr("31", "39");
+export const green = sgr("32", "39");
+export const yellow = sgr("33", "39");
+export const blue = sgr("34", "39");
+export const magenta = sgr("35", "39");
+export const cyan = sgr("36", "39");
+export const gray = sgr("90", "39");
+/** 256-color foreground (falls back to plain text without color). */
+export const fg = (n) => sgr(`38;5;${n}`, "39");
+export const colorEnabled = color;
+export const fmtTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(n >= 10_000 ? 0 : 1)}k` : String(n));
+export function clip(text, maxLines, maxCols = 160) {
+    const lines = text.replace(/\s+$/, "").split("\n");
+    const shown = lines.slice(0, maxLines).map((l) => (l.length > maxCols ? l.slice(0, maxCols - 1) + "…" : l));
+    return shown.join("\n") + (lines.length > maxLines ? `\n… (+${lines.length - maxLines} more lines)` : "");
+}
+export function ago(d, now = Date.now()) {
+    const s = Math.max(0, Math.round((now - d.getTime()) / 1000));
+    if (s < 60)
+        return "just now";
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ago`;
+    if (s < 86400)
+        return `${Math.floor(s / 3600)}h ago`;
+    return `${Math.floor(s / 86400)}d ago`;
+}
+// ---- display width (ANSI-aware; Hangul/CJK/emoji are double width) ----
+export const width = (s) => stringWidth(s);
+const URL_RE = /^(?:\x1b\[[0-9;]*m)*(?:https?|file):\/\/\S/;
+/**
+ * Wrap styled text to `cols`, breaking a word only when it is wider than a line. A URL is never broken: it stays one
+ * run of characters (the terminal soft-wraps it), so the terminal can still open it.
+ */
+export const wrap = (s, cols) => {
+    if (s === "")
+        return [""];
+    const n = Math.max(1, cols);
+    const hard = !s.split(/\s+/).some((w) => URL_RE.test(w) && width(w) > n);
+    return wrapAnsi(s, n, { hard, trim: false }).split("\n");
+};
+/** Cut styled text to at most `cols` display columns, adding … when it was cut. */
+export function truncate(s, cols) {
+    if (width(s) <= cols)
+        return s;
+    let out = "";
+    let w = 0;
+    // walk code points, copying ANSI sequences without counting them
+    const re = /\x1b\[[0-9;]*m|[^\x1b]/gu;
+    for (const m of s.matchAll(re)) {
+        const tok = m[0];
+        if (tok.startsWith("\x1b")) {
+            out += tok;
+            continue;
+        }
+        const cw = width(tok);
+        if (w + cw > cols - 1)
+            break;
+        out += tok;
+        w += cw;
+    }
+    return out + (colorEnabled ? "\x1b[0m" : "") + "…";
+}
+export const padEnd = (s, cols) => s + " ".repeat(Math.max(0, cols - width(s)));
+export const stripAnsi = (s) => s.replace(/\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+/** Untrusted text (model output, file contents, tool results) must never act on the terminal: escapes become visible symbols. */
+export const visible = (s) => s.replace(/\t/g, "  ").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, (c) => (c === "\x1b" ? "␛" : "�"));
+/**
+ * Invisible or reordering characters ("Trojan Source"): every format character (zero-width, bidi controls and marks,
+ * soft hyphen, the BOM, tag characters), line and paragraph separators, blank-looking fillers and variation selectors.
+ */
+const HIDDEN = /[\p{Cf}\p{Zl}\p{Zp}\u115f\u1160\u3164\uffa0\u2800\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu;
+const mark = (c) => `⟨U+${c.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}⟩`;
+/** Untrusted text made fully visible: control characters as symbols (visible) and invisible characters as ⟨U+XXXX⟩. */
+export const reveal = (s) => visible(s).replace(HIDDEN, mark);
+/** True when text to be approved holds characters that change how it looks (controls, bidi, zero-width). */
+export const hasHiddenChars = (s) => /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(s.replace(/\r\n/g, "\n")) || new RegExp(HIDDEN.source, "u").test(s);
+/**
+ * Text the user is asked to approve (a command, MCP arguments), shown completely: every line wrapped to `cols`, never
+ * cut at the width; control, zero-width and bidi characters shown as visible marks; runs of 8+ spaces collapsed to a
+ * visible count, so nothing can hide after a wall of blanks.
+ */
+export function approvalText(s, cols) {
+    const out = [];
+    for (const line of s.replace(/\r\n/g, "\n").split("\n")) {
+        // any blank run, including no-break and ideographic spaces, so nothing can be pushed out of view
+        const shown = reveal(line).replace(/\s{8,}/g, (m) => `⟨${m.length} blanks⟩`);
+        out.push(...wrap(shown, Math.max(10, cols)));
+    }
+    return out;
+}
+/** Same for streamed text, where newlines and tabs are content (a lone \r would let text overwrite earlier output). */
+export const safeText = (s) => s.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, (c) => (c === "\x1b" ? "␛" : "�"));
+/** Credits with sensible precision (OICKI reports fractions of a credit). */
+export const fmtCredits = (c) => (c >= 100 ? Math.round(c).toLocaleString() : c >= 1 ? c.toFixed(1) : c.toFixed(3));

package/dist/update.js

@@ -0,0 +1,64 @@
+/**
+ * Update notice: at most once a day, a background request to the npm registry for OAKODE's published versions. The
+ * answer is cached and shown at the next start, so startup never waits for the network. Nothing about the user is
+ * sent beyond what any HTTP request carries. Off with OAKODE_NO_UPDATE_CHECK=1, in CI, and when not on a terminal.
+ */
+import { join } from "node:path";
+import { VERSION, home, readJson, writeJson } from "./config.js";
+const DAY = 24 * 3600_000;
+const file = () => join(home(), "update-check.json");
+/** -1, 0 or 1. Semver order, including prereleases (1.0.0-rc.1 < 1.0.0-rc.2 < 1.0.0). */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core, pre] = v.replace(/^v/, "").split("-", 2);
+        return { nums: core.split(".").map((x) => Number(x) || 0), pre: pre?.split(".") };
+    };
+    const x = parse(a), y = parse(b);
+    for (let i = 0; i < 3; i++)
+        if ((x.nums[i] ?? 0) !== (y.nums[i] ?? 0))
+            return (x.nums[i] ?? 0) < (y.nums[i] ?? 0) ? -1 : 1;
+    if (!x.pre || !y.pre)
+        return x.pre ? -1 : y.pre ? 1 : 0;
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i], q = y.pre[i];
+        if (p === undefined || q === undefined)
+            return p === undefined ? -1 : 1;
+        if (p === q)
+            continue;
+        const pn = /^\d+$/.test(p), qn = /^\d+$/.test(q);
+        if (pn && qn)
+            return Number(p) < Number(q) ? -1 : 1;
+        if (pn !== qn)
+            return pn ? -1 : 1;
+        return p < q ? -1 : 1;
+    }
+    return 0;
+}
+export const updateCheckEnabled = (env = process.env, tty = process.stdout.isTTY === true) => tty && !env.CI && !env.OAKODE_NO_UPDATE_CHECK;
+/** A one-line notice if a newer version is known (from the cache), else undefined. Prereleases follow the `next` tag. */
+export function updateNotice(current = VERSION) {
+    const c = readJson(file());
+    // the registry's answer is printed and offered as a command: only an exact, short version string is accepted
+    const candidates = [c?.latest, current.includes("-") ? c?.next : undefined].filter((v) => typeof v === "string" && v.length <= 40 && /^\d+\.\d+\.\d+(-[0-9A-Za-z.]+)?$/.test(v));
+    const newest = candidates.sort(compareVersions).at(-1);
+    if (!newest || compareVersions(newest, current) <= 0)
+        return undefined;
+    return `OAKODE ${newest} is available (you have ${current}). Update: npm install -g oakode@${newest}`;
+}
+/** Refreshes the cache in the background when it is older than a day. Never throws, never blocks. */
+export function refreshUpdateCache(fetchImpl = fetch) {
+    const c = readJson(file());
+    if (c && Date.now() - c.checkedAt < DAY)
+        return Promise.resolve();
+    return fetchImpl(process.env.OAKODE_REGISTRY_URL ?? "https://registry.npmjs.org/-/package/oakode/dist-tags", { signal: AbortSignal.timeout(5000) })
+        .then(async (r) => {
+        const tags = r.ok ? (await r.json()) : {};
+        writeJson(file(), { checkedAt: Date.now(), latest: tags.latest, next: tags.next });
+    })
+        .catch(() => {
+        try {
+            writeJson(file(), { ...c, checkedAt: Date.now() }); // offline: try again tomorrow
+        }
+        catch { }
+    });
+}

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "oakode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.1",
+  "description": "A coding agent for your terminal, powered by OICKI",
+  "keywords": [
+    "agent",
+    "ai",
+    "cli",
+    "coding-agent",
+    "oicki",
+    "terminal"
+  ],
+  "homepage": "https://github.com/hjun1052/oakode#readme",
+  "bugs": {
+    "url": "https://github.com/hjun1052/oakode/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hjun1052/oakode.git"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "oakode": "dist/main.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('dist/main.js', 0o755)\"",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.ts",
+    "start": "node src/main.ts",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "diff": "^9.0.0",
+    "highlight.js": "^11.12.0",
+    "marked": "^18.1.1",
+    "marked-cjk-friendly": "^0.1.3",
+    "string-width": "^8.3.0",
+    "wrap-ansi": "^10.0.2",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.0"
+  }
+}