@xingjisoft/neutrino 0.1.0

package/dist/screens/agentHistory.js

@@ -0,0 +1,99 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { truncateByWidth } from "../width.js";
+import { listAgentSessions, loadAgentMessages, } from "../agents.js";
+import { AgentConversationScreen } from "./agentConversation.js";
+export class AgentHistoryScreen extends Screen {
+    agent;
+    label;
+    sessions = [];
+    selectedIdx = 0;
+    scrollTop = 0;
+    constructor(agent, label) {
+        super();
+        this.agent = agent;
+        this.label = label;
+    }
+    onActivate() {
+        this.sessions = listAgentSessions(this.agent);
+        this.selectedIdx = 0;
+        this.scrollTop = 0;
+    }
+    move(delta) {
+        if (this.sessions.length === 0)
+            return;
+        this.selectedIdx = (this.selectedIdx + delta + this.sessions.length) % this.sessions.length;
+        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 === "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.selectedIdx >= this.sessions.length)
+            return;
+        const s = this.sessions[this.selectedIdx];
+        const messages = loadAgentMessages(this.agent, s.id);
+        this.app.pushScreen(new AgentConversationScreen(`${this.label} · ${s.title || s.id}`, messages));
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        buf.centerText(2, this.label, { fg: C.accent, bold: true });
+        buf.centerText(3, "Select a session to view", { fg: C.dim });
+        const listTop = 5;
+        const listBottom = h - 2;
+        const viewH = Math.max(1, listBottom - listTop);
+        if (this.sessions.length === 0) {
+            buf.centerText(listTop + 1, "No sessions yet", { fg: C.dim });
+            buf.centerText(listBottom, "Esc back", { fg: C.dim });
+            return;
+        }
+        const rows = [];
+        const itemBounds = [];
+        for (const s of this.sessions) {
+            const start = rows.length;
+            const created = (s.updated_at || s.created_at || "").slice(0, 19);
+            rows.push(`${created} | ${s.title || s.id}`);
+            if (s.model)
+                rows.push(`    ${s.model}`);
+            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 text = (isSelectedFirst ? "▸ " : "  ") + rows[ri];
+            buf.writeText(0, y, truncateByWidth(text, w), isSelected ? { fg: C.accent, bg: C.highlightBg } : { fg: C.assistant });
+        }
+        buf.centerText(listBottom, "↑/↓ select  ·  Enter view  ·  Esc back", { fg: C.dim });
+    }
+}

package/dist/screens/agentSelect.js

@@ -0,0 +1,71 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { drawTabButton } from "../ui.js";
+import { AgentHistoryScreen } from "./agentHistory.js";
+const AGENTS = [
+    { id: "claude", label: "Claude Code" },
+    { id: "codex", label: "Codex" },
+    { id: "opencode", label: "OpenCode" },
+];
+export class AgentSelectScreen extends Screen {
+    selectedIdx = 0;
+    scrollBtn = 0;
+    onActivate() {
+        this.selectedIdx = 0;
+        this.scrollBtn = 0;
+    }
+    move(delta) {
+        if (AGENTS.length === 0)
+            return;
+        let idx = this.selectedIdx + delta;
+        if (idx < 0)
+            idx = AGENTS.length - 1;
+        if (idx >= AGENTS.length)
+            idx = 0;
+        this.selectedIdx = idx;
+        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.confirm();
+        else if (key.name === "escape")
+            this.app.popScreen();
+    }
+    confirm() {
+        const agent = AGENTS[this.selectedIdx];
+        if (!agent)
+            return;
+        this.app.pushScreen(new AgentHistoryScreen(agent.id, agent.label));
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        buf.centerText(2, "Other Agents", { fg: C.accent, bold: true });
+        buf.centerText(3, "Select an agent to open its history", { fg: C.white });
+        const listTop = 5;
+        const btnH = 3;
+        const stride = btnH;
+        const hintRow = h - 1;
+        const maxVisible = Math.max(1, Math.floor((hintRow - listTop) / stride));
+        if (this.selectedIdx < this.scrollBtn)
+            this.scrollBtn = this.selectedIdx;
+        if (this.selectedIdx >= this.scrollBtn + maxVisible)
+            this.scrollBtn = this.selectedIdx - maxVisible + 1;
+        if (this.scrollBtn < 0)
+            this.scrollBtn = 0;
+        let y = listTop;
+        for (let i = this.scrollBtn; i < AGENTS.length; i++) {
+            if (y + btnH > hintRow)
+                break;
+            drawTabButton(buf, 1, y, w - 2, AGENTS[i].label, i === this.selectedIdx, "left");
+            y += stride;
+        }
+        buf.centerText(hintRow, "↑/↓ select  ·  Enter open  ·  Esc back", { fg: C.dim });
+    }
+}

package/dist/screens/chat.js

@@ -0,0 +1,490 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { loadPrompt, saveSession, } from "../config.js";
+import { drawHeader } from "../header.js";
+import { drawInputBox, wrapText } from "../ui.js";
+import { ellipsize, displayWidth } from "../width.js";
+import { LLMClient } from "../llm/client.js";
+import { executeTool, getToolDefinitions } from "../llm/tools.js";
+const TOOLS = getToolDefinitions();
+function parseArgs(s) {
+    if (!s || !s.trim())
+        return {};
+    try {
+        const v = JSON.parse(s);
+        return typeof v === "object" && v !== null ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+export class ChatScreen extends Screen {
+    initialMessage;
+    loadedMessages = null;
+    sessionId = null;
+    loadedProvider = null;
+    loadedModel = null;
+    loadedIntensity = null;
+    loadedTokens = null;
+    modelProvider = "DeepSeek";
+    model = { name: "deepseek-chat", url: "https://api.deepseek.com/v1", api_key: "", supports_streaming: true };
+    intensity = "High";
+    tokens = { prompt: 0, completion: 0 };
+    showInfo = false;
+    messages = [];
+    streamingContent = null;
+    busy = false;
+    paused = false;
+    queued = null;
+    turnToken = 0;
+    inputValue = "";
+    cursor = 0;
+    scrollTop = 0;
+    followBottom = true;
+    lastEscTime = 0;
+    initialized = false;
+    constructor(initialMessage = "") {
+        super();
+        this.initialMessage = initialMessage;
+    }
+    onActivate() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const st = this.app.state;
+        this.modelProvider = this.loadedProvider ?? st.selectedProvider;
+        this.model = {
+            name: this.loadedModel ?? st.selectedModelName,
+            url: st.selectedModelUrl,
+            api_key: st.selectedModelApiKey,
+            supports_streaming: st.selectedModelStreaming,
+        };
+        this.intensity = this.loadedIntensity ?? st.selectedIntensity;
+        if (this.loadedTokens) {
+            this.tokens = { prompt: this.loadedTokens.prompt, completion: this.loadedTokens.completion };
+        }
+        this.messages.push({
+            role: "system",
+            content: `Model: ${this.modelProvider}/${this.model.name} | Intensity: ${this.intensity}`,
+        });
+        for (const m of this.loadedMessages ?? []) {
+            this.messages.push(m);
+        }
+        if (this.initialMessage) {
+            this.send(this.initialMessage);
+        }
+        else {
+            this.app.render();
+        }
+    }
+    onKey(key) {
+        if (this.showInfo) {
+            this.showInfo = false;
+            this.app.render();
+            if (key.name === "escape")
+                return;
+        }
+        if (key.name === "escape") {
+            const now = Date.now();
+            if (now - this.lastEscTime < 400) {
+                this.lastEscTime = 0;
+                this.togglePause();
+            }
+            else {
+                this.lastEscTime = now;
+            }
+            return;
+        }
+        if (key.name === "return") {
+            const text = this.inputValue.trim();
+            if (text)
+                this.send(text);
+            return;
+        }
+        if (key.name === "up") {
+            this.followBottom = false;
+            this.scrollTop = Math.max(0, this.scrollTop - 1);
+            this.app.render();
+            return;
+        }
+        if (key.name === "down") {
+            this.scrollTop += 1;
+            this.app.render();
+            return;
+        }
+        if (key.name === "pageup") {
+            this.followBottom = false;
+            this.scrollTop = Math.max(0, this.scrollTop - 10);
+            this.app.render();
+            return;
+        }
+        if (key.name === "pagedown") {
+            this.scrollTop += 10;
+            this.app.render();
+            return;
+        }
+        if (key.name === "left") {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.app.render();
+            }
+            return;
+        }
+        if (key.name === "right") {
+            if (this.cursor < this.inputValue.length) {
+                this.cursor++;
+                this.app.render();
+            }
+            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 === "b") {
+            this.save();
+            this.app.popScreen();
+            return;
+        }
+        if (key.ctrl && key.name === "l") {
+            const sysText = this.messages[0] && this.messages[0].role === "system" ? this.messages[0].content : "";
+            this.messages = [{ role: "system", content: sysText }];
+            this.streamingContent = null;
+            this.scrollTop = 0;
+            this.followBottom = true;
+            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();
+        }
+    }
+    onMouse(ev) {
+        if (ev.type === "click") {
+            if (ev.y === 0 && ev.x >= this.app.width - 3) {
+                this.showInfo = !this.showInfo;
+                this.app.render();
+                return;
+            }
+            if (this.showInfo) {
+                this.showInfo = false;
+                this.app.render();
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            if (ev.dir === -1) {
+                this.followBottom = false;
+                this.scrollTop = Math.max(0, this.scrollTop - 3);
+            }
+            else {
+                this.scrollTop += 3;
+            }
+            this.app.render();
+        }
+    }
+    togglePause() {
+        if (!this.busy && !this.queued)
+            return;
+        this.paused = !this.paused;
+        if (this.paused) {
+            this.turnToken++;
+            this.busy = false;
+            this.app.state.isThinking = false;
+            this.save();
+        }
+        this.app.render();
+        this.maybeFlushQueue();
+    }
+    maybeFlushQueue() {
+        if (this.queued) {
+            this.queued = null;
+            this.startTurn();
+        }
+    }
+    send(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        this.messages.push({ role: "user", content: trimmed });
+        this.inputValue = "";
+        this.cursor = 0;
+        this.followBottom = true;
+        if (this.busy && !this.paused) {
+            this.queued = trimmed;
+            this.app.render();
+            return;
+        }
+        this.startTurn();
+    }
+    startTurn() {
+        this.busy = true;
+        this.paused = false;
+        this.app.state.isThinking = true;
+        const token = ++this.turnToken;
+        const apiMessages = this.buildApiMessages();
+        this.streamingContent = "";
+        this.app.render();
+        void this.agentLoop(apiMessages, token);
+    }
+    buildApiMessages() {
+        const api = [{ role: "system", content: loadPrompt() }];
+        for (const m of this.messages) {
+            if (m.role === "user" || m.role === "assistant") {
+                api.push({ role: m.role, content: m.content });
+            }
+        }
+        return api;
+    }
+    async agentLoop(apiMessages, token) {
+        try {
+            while (true) {
+                if (token !== this.turnToken)
+                    return;
+                const client = new LLMClient(this.model, this.modelProvider, this.intensity);
+                let content = "";
+                let hasContent = false;
+                let aborted = false;
+                for await (const chunk of client.streamTurn(apiMessages, TOOLS)) {
+                    if (token !== this.turnToken || this.paused) {
+                        aborted = true;
+                        break;
+                    }
+                    content += chunk;
+                    hasContent = true;
+                    this.streamingContent = content;
+                    this.app.render();
+                }
+                if (client.usage) {
+                    this.tokens.prompt += client.usage.prompt;
+                    this.tokens.completion += client.usage.completion;
+                }
+                else {
+                    this.tokens.completion += Math.max(1, Math.ceil(content.length / 4));
+                }
+                if (token !== this.turnToken) {
+                    if (content)
+                        this.messages.push({ role: "assistant", content });
+                    this.streamingContent = null;
+                    this.app.render();
+                    return;
+                }
+                if (aborted || this.paused) {
+                    if (content)
+                        this.messages.push({ role: "assistant", content });
+                    this.streamingContent = null;
+                    this.app.render();
+                    this.onTurnFinished();
+                    return;
+                }
+                const toolCalls = client.toolCalls;
+                if (toolCalls.length === 0) {
+                    if (hasContent)
+                        this.messages.push({ role: "assistant", content });
+                    this.streamingContent = null;
+                    break;
+                }
+                if (hasContent)
+                    this.messages.push({ role: "assistant", content });
+                this.streamingContent = null;
+                apiMessages.push({
+                    role: "assistant",
+                    content,
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+                for (const tc of toolCalls) {
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    const args = parseArgs(tc.arguments);
+                    const toolMsg = { role: "tool", name: tc.name, arguments: args, result: "" };
+                    this.messages.push(toolMsg);
+                    this.app.render();
+                    const result = await executeTool(tc.name, args);
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    toolMsg.result = result;
+                    apiMessages.push({ role: "tool", tool_call_id: tc.id, content: result });
+                    this.app.render();
+                }
+            }
+            this.onTurnFinished();
+        }
+        catch (e) {
+            const err = e instanceof Error ? e.message : String(e);
+            this.messages.push({ role: "assistant", content: (this.streamingContent ?? "") + `\n[Error: ${err}]` });
+            this.streamingContent = null;
+            this.onTurnFinished();
+        }
+    }
+    onTurnFinished() {
+        this.busy = false;
+        this.paused = false;
+        this.app.state.isThinking = false;
+        this.save();
+        this.app.render();
+        this.maybeFlushQueue();
+    }
+    save() {
+        const chatMessages = this.messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "tool");
+        if (chatMessages.length === 0)
+            return;
+        try {
+            this.sessionId = saveSession(chatMessages, this.model.name, this.modelProvider, this.intensity, process.cwd(), this.sessionId ?? undefined, this.tokens);
+        }
+        catch {
+            // ignore save errors
+        }
+    }
+    buildLines(width) {
+        const lines = [];
+        const push = (text, style) => {
+            for (const ln of wrapText(text, width))
+                lines.push({ text: ln, style });
+        };
+        for (const m of this.messages) {
+            if (m.role === "system") {
+                push(m.content, { fg: C.dim });
+            }
+            else if (m.role === "user") {
+                lines.push({ text: "You:", style: { fg: C.accent, bold: true } });
+                push(m.content, { fg: C.user });
+                lines.push({ text: "", style: {} });
+            }
+            else if (m.role === "assistant") {
+                lines.push({ text: "Neutrino:", style: { fg: C.accent, bold: true } });
+                push(m.content, { fg: C.assistant });
+                lines.push({ text: "", style: {} });
+            }
+            else if (m.role === "tool") {
+                lines.push({ text: `⚙ ${m.name}`, style: { fg: C.toolHeader, bold: true } });
+                const argText = m.arguments.command ?? m.arguments.path ?? "";
+                if (argText)
+                    lines.push({ text: "  " + argText, style: { fg: C.dim } });
+                push(m.result || "(no output)", { fg: C.dim });
+                lines.push({ text: "", style: {} });
+            }
+        }
+        if (this.streamingContent !== null) {
+            lines.push({ text: "Neutrino:", style: { fg: C.accent, bold: true } });
+            push(this.streamingContent, { fg: C.assistant });
+        }
+        return lines;
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        let status = "";
+        let statusStyle = { fg: C.dim };
+        if (this.queued) {
+            status = "Will send when paused or idle...";
+            statusStyle = { fg: C.amber };
+        }
+        else if (this.paused) {
+            status = "PAUSED — press ESC ESC to resume";
+            statusStyle = { fg: C.amber, bold: true };
+        }
+        else if (this.busy) {
+            status = "Streaming... press ESC ESC to pause";
+            statusStyle = { fg: C.dim };
+        }
+        if (status)
+            buf.centerText(1, status.slice(0, w), statusStyle);
+        const inputY = h - 4;
+        const logTop = 2;
+        const logBottom = inputY - 2;
+        const viewH = Math.max(1, logBottom - logTop + 1);
+        const lines = this.buildLines(Math.max(10, w - 4));
+        const maxScroll = Math.max(0, lines.length - viewH);
+        if (this.followBottom)
+            this.scrollTop = maxScroll;
+        if (this.scrollTop > maxScroll) {
+            this.scrollTop = maxScroll;
+            this.followBottom = true;
+        }
+        if (this.scrollTop < 0)
+            this.scrollTop = 0;
+        for (let y = logTop; y <= logBottom; y++) {
+            const li = this.scrollTop + (y - logTop);
+            if (li >= lines.length)
+                break;
+            const line = lines[li];
+            buf.writeText(2, y, line.text.slice(0, w - 2), line.style);
+        }
+        const inW = Math.max(12, w - 2);
+        drawInputBox(buf, 1, inputY, inW, this.inputValue, this.cursor, {
+            active: true,
+            dimmed: this.busy,
+            placeholder: "Type a message...",
+        });
+        const hintY = h - 1;
+        const hints = "Enter send  ·  ESC ESC pause  ·  Ctrl+B menu  ·  Ctrl+L clear";
+        const hintW = displayWidth(hints);
+        const hintX = Math.max(0, w - 1 - hintW);
+        const pathAvail = Math.max(0, hintX - 2);
+        buf.writeText(1, hintY, ellipsize(process.cwd(), pathAvail), { fg: C.dim });
+        buf.writeText(hintX, hintY, hints, { fg: C.dim });
+        this.renderInfoOverlay(buf);
+    }
+    renderInfoOverlay(buf) {
+        const w = buf.width;
+        buf.set(w - 2, 0, "ⓘ", { fg: C.accent, bg: C.highlightBg, bold: true });
+        if (!this.showInfo)
+            return;
+        const total = this.tokens.prompt + this.tokens.completion;
+        const lines = [
+            "Tokens",
+            `Prompt: ${this.tokens.prompt}`,
+            `Completion: ${this.tokens.completion}`,
+            `Total: ${total}`,
+        ];
+        let contentW = 8;
+        for (const l of lines)
+            contentW = Math.max(contentW, displayWidth(l));
+        let boxW = contentW + 4;
+        if (boxW > w - 2)
+            boxW = Math.max(6, w - 2);
+        const boxX = w - 1 - boxW;
+        const boxY = 1;
+        const boxH = lines.length + 2;
+        buf.fillRect(boxX, boxY, boxW, boxH, { bg: C.black });
+        buf.drawBox(boxX, boxY, boxW, boxH, { fg: C.accent });
+        for (let i = 0; i < lines.length; i++) {
+            const style = i === 0 ? { fg: C.accent, bg: C.black, bold: true } : { fg: C.assistant, bg: C.black };
+            buf.writeText(boxX + 2, boxY + 1 + i, lines[i].slice(0, boxW - 4), style);
+        }
+    }
+}