@xingjisoft/neutrino 0.1.0

package/dist/screens/history.js

@@ -0,0 +1,114 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { deleteSession, listSessions, loadSession } from "../config.js";
+import { drawHeader } from "../header.js";
+export class HistoryScreen extends Screen {
+    sessions = [];
+    selectedIdx = 0;
+    scrollTop = 0;
+    onActivate() {
+        this.sessions = listSessions();
+        this.selectedIdx = this.sessions.length > 0 ? 1 : 0;
+        this.scrollTop = 0;
+    }
+    move(delta) {
+        const count = this.sessions.length + 1;
+        this.selectedIdx = (this.selectedIdx + delta + count) % count;
+        this.app.render();
+    }
+    onKey(key) {
+        if (key.name === "up")
+            this.move(-1);
+        else if (key.name === "down")
+            this.move(1);
+        else if (key.name === "enter" || key.name === "return")
+            this.loadSelected();
+        else if (key.name === "delete")
+            this.deleteSelected();
+        else if (key.name === "escape")
+            this.app.popScreen();
+    }
+    onMouse(ev) {
+        if (ev.type === "wheel") {
+            this.scrollTop = Math.max(0, this.scrollTop + (ev.dir === -1 ? -3 : 3));
+            this.app.render();
+        }
+    }
+    loadSelected() {
+        if (this.selectedIdx === 0) {
+            this.app.openAgentSelect();
+            return;
+        }
+        const session = this.sessions[this.selectedIdx - 1];
+        if (!session)
+            return;
+        const data = loadSession(session.id);
+        if (data) {
+            this.app.popScreen();
+            this.app.loadSession(data);
+        }
+    }
+    deleteSelected() {
+        if (this.selectedIdx === 0)
+            return;
+        const session = this.sessions[this.selectedIdx - 1];
+        if (!session)
+            return;
+        deleteSession(session.id);
+        this.sessions = listSessions();
+        this.selectedIdx = Math.min(this.selectedIdx, this.sessions.length);
+        this.app.render();
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        buf.centerText(2, "History", { fg: C.accent, bold: true });
+        buf.centerText(3, "Select a session to load", { fg: C.dim });
+        const listTop = 5;
+        const listBottom = h - 2;
+        const viewH = Math.max(1, listBottom - listTop);
+        const rows = [];
+        const itemBounds = [];
+        rows.push("Open other Agent's history");
+        itemBounds.push({ start: 0, end: 1 });
+        rows.push("");
+        for (const s of this.sessions) {
+            const start = rows.length;
+            const created = (s.created_at || "").slice(0, 19);
+            rows.push(`${created} | ${s.provider}/${s.model} (${s.intensity}) | ${s.message_count} msgs`);
+            if (s.title)
+                rows.push(`    ${s.title}`);
+            if (s.cwd)
+                rows.push(`    ${s.cwd}`);
+            itemBounds.push({ start, end: rows.length });
+        }
+        if (this.selectedIdx < 0)
+            this.selectedIdx = 0;
+        if (this.selectedIdx >= itemBounds.length)
+            this.selectedIdx = itemBounds.length - 1;
+        const selected = itemBounds[this.selectedIdx];
+        const firstRowOfSelected = selected.start;
+        if (firstRowOfSelected < this.scrollTop)
+            this.scrollTop = firstRowOfSelected;
+        if (firstRowOfSelected >= this.scrollTop + viewH)
+            this.scrollTop = firstRowOfSelected - viewH + 1;
+        if (this.scrollTop > rows.length - viewH)
+            this.scrollTop = Math.max(0, rows.length - viewH);
+        for (let y = listTop; y < listBottom; y++) {
+            const ri = this.scrollTop + (y - listTop);
+            if (ri < 0 || ri >= rows.length)
+                break;
+            const isSelected = ri >= selected.start && ri < selected.end;
+            const isSelectedFirst = ri === selected.start;
+            const row = rows[ri];
+            const prefix = isSelectedFirst ? "▸ " : "  ";
+            const style = isSelected ? { fg: C.accent, bg: C.highlightBg } : { fg: C.assistant };
+            buf.writeText(0, y, (prefix + row).slice(0, w), style);
+        }
+        if (this.sessions.length === 0) {
+            buf.centerText(listTop + 1, "No sessions yet", { fg: C.dim });
+        }
+        buf.centerText(listBottom, "↑/↓ select  ·  Enter load  ·  Delete delete  ·  Esc back", { fg: C.dim });
+    }
+}

package/dist/screens/modelSelect.js

@@ -0,0 +1,146 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { INTENSITY_LEVELS, getModelsByProvider } from "../config.js";
+import { drawHeader } from "../header.js";
+import { drawTabButton } from "../ui.js";
+export class ModelSelectScreen extends Screen {
+    level = 0;
+    providers = [];
+    modelMap = {};
+    selectedProviderIdx = 0;
+    selectedModelIdx = 0;
+    selectedIntensityIdx = 2;
+    scrollBtn = 0;
+    onActivate() {
+        const map = getModelsByProvider();
+        this.providers = Object.keys(map);
+        this.modelMap = map;
+        this.selectedProviderIdx = 0;
+        this.selectedModelIdx = 0;
+        this.selectedIntensityIdx = 2;
+        this.scrollBtn = 0;
+    }
+    currentList() {
+        if (this.level === 0)
+            return this.providers;
+        if (this.level === 1)
+            return (this.modelMap[this.providers[this.selectedProviderIdx]] ?? []).map((m) => m.name);
+        return INTENSITY_LEVELS;
+    }
+    currentIdx() {
+        if (this.level === 0)
+            return this.selectedProviderIdx;
+        if (this.level === 1)
+            return this.selectedModelIdx;
+        return this.selectedIntensityIdx;
+    }
+    setIdx(idx) {
+        if (this.level === 0)
+            this.selectedProviderIdx = idx;
+        else if (this.level === 1)
+            this.selectedModelIdx = idx;
+        else
+            this.selectedIntensityIdx = idx;
+    }
+    move(delta) {
+        const list = this.currentList();
+        if (list.length === 0)
+            return;
+        let idx = this.currentIdx() + delta;
+        if (idx < 0)
+            idx = list.length - 1;
+        if (idx >= list.length)
+            idx = 0;
+        this.setIdx(idx);
+        if (this.level === 0)
+            this.selectedModelIdx = 0;
+        this.app.render();
+    }
+    confirm() {
+        if (this.level === 0) {
+            if (this.providers.length === 0)
+                return;
+            this.level = 1;
+            this.selectedModelIdx = 0;
+            this.app.render();
+            return;
+        }
+        if (this.level === 1) {
+            const models = this.modelMap[this.providers[this.selectedProviderIdx]] ?? [];
+            if (models.length === 0)
+                return;
+            this.level = 2;
+            this.app.render();
+            return;
+        }
+        const providerName = this.providers[this.selectedProviderIdx];
+        const models = this.modelMap[providerName] ?? [];
+        const model = models[this.selectedModelIdx];
+        if (!model)
+            return;
+        const intensity = INTENSITY_LEVELS[this.selectedIntensityIdx];
+        this.app.setModelConfig(providerName, model, intensity);
+        this.app.popScreen();
+    }
+    goBack() {
+        if (this.level > 0) {
+            this.level--;
+            this.app.render();
+        }
+        else {
+            this.app.popScreen();
+        }
+    }
+    onKey(key) {
+        if (key.name === "up")
+            this.move(-1);
+        else if (key.name === "down")
+            this.move(1);
+        else if (key.name === "enter" || key.name === "return")
+            this.confirm();
+        else if (key.name === "escape")
+            this.goBack();
+        else if (key.name === "left")
+            this.goBack();
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        const list = this.currentList();
+        const idx = this.currentIdx();
+        buf.centerText(2, "Model Selection", { fg: C.accent, bold: true });
+        let subtitle = "";
+        if (this.level === 0)
+            subtitle = "Select a provider";
+        else if (this.level === 1)
+            subtitle = this.providers[this.selectedProviderIdx] ?? "";
+        else
+            subtitle = `Model: ${this.currentModelName()} - Select Intensity`;
+        buf.centerText(3, subtitle, { fg: C.white });
+        const listTop = 5;
+        const btnH = 3;
+        const btnGap = 0;
+        const stride = btnH + btnGap;
+        const hintRow = h - 1;
+        const maxVisible = Math.max(1, Math.floor((hintRow - listTop) / stride));
+        if (idx < this.scrollBtn)
+            this.scrollBtn = idx;
+        if (idx >= this.scrollBtn + maxVisible)
+            this.scrollBtn = idx - maxVisible + 1;
+        if (this.scrollBtn < 0)
+            this.scrollBtn = 0;
+        let y = listTop;
+        for (let i = this.scrollBtn; i < list.length; i++) {
+            if (y + btnH > hintRow)
+                break;
+            drawTabButton(buf, 1, y, w - 2, list[i], i === idx, "left");
+            y += stride;
+        }
+        buf.centerText(hintRow, "↑/↓ select  ·  Enter confirm  ·  Esc back", { fg: C.dim });
+    }
+    currentModelName() {
+        const models = this.modelMap[this.providers[this.selectedProviderIdx]] ?? [];
+        return models[this.selectedModelIdx]?.name ?? "";
+    }
+}

package/dist/screens/settings.js

@@ -0,0 +1,70 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { INTENSITY_LEVELS, MODEL_FILE, loadConfig, saveConfig } from "../config.js";
+import { drawHeader } from "../header.js";
+import { centerVertically } from "../ui.js";
+export class SettingsScreen extends Screen {
+    intensityIdx = 2;
+    onActivate() {
+        const config = loadConfig();
+        const current = String(config.default_intensity ?? "High");
+        const i = INTENSITY_LEVELS.indexOf(current);
+        this.intensityIdx = i >= 0 ? i : 2;
+    }
+    onKey(key) {
+        if (key.name === "up") {
+            this.intensityIdx = (this.intensityIdx + INTENSITY_LEVELS.length - 1) % INTENSITY_LEVELS.length;
+            this.app.render();
+        }
+        else if (key.name === "down") {
+            this.intensityIdx = (this.intensityIdx + 1) % INTENSITY_LEVELS.length;
+            this.app.render();
+        }
+        else if (key.name === "enter" || key.name === "return") {
+            this.save();
+        }
+        else if (key.name === "escape") {
+            this.save();
+            this.app.popScreen();
+        }
+    }
+    save() {
+        const config = loadConfig();
+        config.default_intensity = INTENSITY_LEVELS[this.intensityIdx];
+        saveConfig(config);
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const h = buf.height;
+        const lines = [
+            "Settings",
+            "",
+            `Model: ${this.app.state.selectedProvider}/${this.app.state.selectedModelName}`,
+            `Default intensity:`,
+        ];
+        const content = INTENSITY_LEVELS.map((l, i) => ({
+            text: l,
+            selected: i === this.intensityIdx,
+        }));
+        const total = lines.length + content.length + 2;
+        const top = centerVertically(h, total);
+        let y = top;
+        buf.centerText(y, lines[0], { fg: C.accent, bold: true });
+        y += 2;
+        buf.centerText(y, lines[2], { fg: C.assistant });
+        y += 1;
+        buf.centerText(y, lines[3], { fg: C.dim });
+        y += 1;
+        for (const c of content) {
+            const text = (c.selected ? "▸ " : "  ") + c.text;
+            buf.centerText(y, text, c.selected ? { fg: C.accent, bg: C.highlightBg } : { fg: C.assistant });
+            y += 1;
+        }
+        y += 1;
+        buf.centerText(y, `model.json: ${MODEL_FILE}`, { fg: C.dim });
+        y += 1;
+        if (y < h) {
+            buf.centerText(y, "↑/↓ change  ·  Enter apply  ·  Esc back", { fg: C.dim });
+        }
+    }
+}

package/dist/screens/start.js

@@ -0,0 +1,129 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { loadLogo } from "../config.js";
+import { drawHeader } from "../header.js";
+import { centerVertically, drawInputBox, drawTabButton } from "../ui.js";
+const TABS = ["Model", "History", "Settings"];
+const LOGO = loadLogo();
+const FOCUS_COUNT = TABS.length + 1; // input box + 3 tabs
+export class StartScreen extends Screen {
+    inputValue = "";
+    cursor = 0;
+    focusIdx = 0; // 0 = input box, 1..3 = tabs
+    onKey(key) {
+        if (key.name === "left" || key.name === "up") {
+            this.move(-1);
+            return;
+        }
+        if (key.name === "right" || key.name === "down") {
+            this.move(1);
+            return;
+        }
+        if (key.name === "return") {
+            if (this.focusIdx === 0) {
+                const text = this.inputValue.trim();
+                if (text)
+                    this.app.startNewChat(text);
+            }
+            else {
+                this.enterTab();
+            }
+            return;
+        }
+        if (this.focusIdx !== 0)
+            return;
+        if (key.name === "backspace") {
+            if (this.cursor > 0) {
+                this.inputValue =
+                    this.inputValue.slice(0, this.cursor - 1) + this.inputValue.slice(this.cursor);
+                this.cursor--;
+                this.app.render();
+            }
+            return;
+        }
+        if (key.name === "delete") {
+            if (this.cursor < this.inputValue.length) {
+                this.inputValue =
+                    this.inputValue.slice(0, this.cursor) + this.inputValue.slice(this.cursor + 1);
+                this.app.render();
+            }
+            return;
+        }
+        if (key.name === "home") {
+            this.cursor = 0;
+            this.app.render();
+            return;
+        }
+        if (key.name === "end") {
+            this.cursor = this.inputValue.length;
+            this.app.render();
+            return;
+        }
+        if (key.ctrl && key.name === "u") {
+            this.inputValue = "";
+            this.cursor = 0;
+            this.app.render();
+            return;
+        }
+        if (!key.ctrl && !key.meta && key.name.length === 1) {
+            this.inputValue =
+                this.inputValue.slice(0, this.cursor) + key.name + this.inputValue.slice(this.cursor);
+            this.cursor++;
+            this.app.render();
+        }
+    }
+    move(delta) {
+        this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
+        this.app.render();
+    }
+    enterTab() {
+        if (this.focusIdx === 1)
+            this.app.openModelConfig();
+        else if (this.focusIdx === 2)
+            this.app.openHistory();
+        else
+            this.app.openSettings();
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        const inputW = Math.min(78, w - 4);
+        const inputX = Math.floor((w - inputW) / 2);
+        const logoLines = LOGO.replace(/\n+$/, "").split("\n");
+        const logoMax = logoLines.reduce((m, l) => Math.max(m, l.length), 0);
+        const logoX = Math.max(0, Math.floor((w - logoMax) / 2));
+        const gap = 1;
+        const inputBoxH = 3;
+        const tabH = 3;
+        const contentH = logoLines.length + 1 + inputBoxH + gap + tabH;
+        const top = centerVertically(h, contentH);
+        let y = top;
+        for (const line of logoLines) {
+            buf.writeText(logoX, y, line, { fg: C.accent, bold: true });
+            y++;
+        }
+        y += 1;
+        drawInputBox(buf, inputX, y, inputW, this.inputValue, this.cursor, {
+            active: this.focusIdx === 0,
+            placeholder: "Type a message to start a new chat...",
+        });
+        y += inputBoxH + gap;
+        const tabGap = 2;
+        const tabInner = inputW - tabGap * (TABS.length - 1);
+        const baseW = Math.floor(tabInner / TABS.length);
+        const extra = tabInner - baseW * TABS.length;
+        let tx = inputX;
+        for (let i = 0; i < TABS.length; i++) {
+            const tw = baseW + (i < extra ? 1 : 0);
+            drawTabButton(buf, tx, y, tw, TABS[i], i === this.focusIdx - 1);
+            tx += tw + tabGap;
+        }
+        const hintY = y + tabH + 1;
+        if (hintY < h) {
+            buf.centerText(hintY, "←/→ / ↑/↓ switch  ·  Enter confirm  ·  Ctrl+E model  ·  Ctrl+Q quit", {
+                fg: C.dim,
+            });
+        }
+    }
+}

package/dist/state.js

@@ -0,0 +1,11 @@
+export function defaultState() {
+    return {
+        selectedProvider: "DeepSeek",
+        selectedModelName: "deepseek-chat",
+        selectedModelUrl: "https://api.deepseek.com/v1",
+        selectedModelApiKey: "",
+        selectedModelStreaming: true,
+        selectedIntensity: "High",
+        isThinking: false,
+    };
+}

package/dist/terminal/buffer.js

@@ -0,0 +1,80 @@
+import { C, EMPTY_STYLE } from "../colors.js";
+import { displayWidth, wcwidth } from "../width.js";
+const emptyCell = () => ({ ch: " ", style: { bg: C.black } });
+function normalize(style) {
+    return style.bg ? style : { ...style, bg: C.black };
+}
+export class Buffer {
+    width;
+    height;
+    cells;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.cells = Array.from({ length: height }, () => Array.from({ length: width }, emptyCell));
+    }
+    set(x, y, ch, style = EMPTY_STYLE) {
+        if (ch === "\r" || ch === "\n")
+            return;
+        if (y < 0 || y >= this.height || x < 0 || x >= this.width)
+            return;
+        this.cells[y][x] = { ch, style: normalize(style) };
+    }
+    writeText(x, y, text, style = EMPTY_STYLE) {
+        if (y < 0 || y >= this.height)
+            return;
+        let col = x;
+        for (const ch of text) {
+            const w = wcwidth(ch.codePointAt(0) ?? 0);
+            if (w === 0) {
+                if (col - 1 >= x && col - 1 >= 0 && col - 1 < this.width) {
+                    this.cells[y][col - 1].ch += ch;
+                }
+                continue;
+            }
+            if (col >= this.width)
+                break;
+            if (col < 0) {
+                col += w;
+                continue;
+            }
+            this.cells[y][col] = { ch, style: normalize(style) };
+            if (w === 2 && col + 1 < this.width) {
+                this.cells[y][col + 1] = { ch: "", style: normalize(style) };
+            }
+            col += w;
+        }
+    }
+    centerText(y, text, style = EMPTY_STYLE) {
+        const w = displayWidth(text);
+        const x = Math.floor((this.width - w) / 2);
+        this.writeText(x, y, text, style);
+    }
+    fillRect(x, y, w, h, style = EMPTY_STYLE) {
+        for (let j = y; j < y + h; j++) {
+            for (let i = x; i < x + w; i++) {
+                this.set(i, j, " ", style);
+            }
+        }
+    }
+    drawBox(x, y, w, h, style = EMPTY_STYLE) {
+        if (w < 2 || h < 2)
+            return;
+        const top = "┌" + "─".repeat(w - 2) + "┐";
+        const bottom = "└" + "─".repeat(w - 2) + "┘";
+        this.writeText(x, y, top, style);
+        for (let j = y + 1; j < y + h - 1; j++) {
+            this.set(x, j, "│", style);
+            this.set(x + w - 1, j, "│", style);
+        }
+        this.writeText(x, y + h - 1, bottom, style);
+    }
+    clear() {
+        for (let j = 0; j < this.height; j++) {
+            const row = this.cells[j];
+            for (let i = 0; i < this.width; i++) {
+                row[i] = { ch: " ", style: { bg: C.black } };
+            }
+        }
+    }
+}