@xingjisoft/neutrino 0.1.0

package/dist/config.js

@@ -0,0 +1,196 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
+export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
+export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
+export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+export const DEFAULT_MODELS = {
+    providers: [
+        {
+            name: "DeepSeek",
+            models: [
+                { name: "deepseek-v4-pro", url: "https://api.deepseek.com/v1", api_key: "", supports_streaming: true },
+                { name: "deepseek-chat", url: "https://api.deepseek.com/v1", api_key: "", supports_streaming: true },
+            ],
+        },
+        {
+            name: "OpenAI",
+            models: [
+                { name: "gpt-4o", url: "https://api.openai.com/v1", api_key: "", supports_streaming: true },
+                { name: "gpt-4o-mini", url: "https://api.openai.com/v1", api_key: "", supports_streaming: true },
+            ],
+        },
+        {
+            name: "Anthropic",
+            models: [
+                { name: "claude-3-5-sonnet-20241022", url: "https://api.anthropic.com/v1", api_key: "", supports_streaming: true },
+            ],
+        },
+    ],
+};
+export const DEFAULT_CONFIG = {
+    language: "en",
+    theme: "default",
+    default_intensity: "High",
+};
+export const INTENSITY_LEVELS = ["Low", "Medium", "High", "Max", "Ultra"];
+export const INTENSITY_PARAMS = {
+    Low: { temperature: 0.1, top_p: 0.1 },
+    Medium: { temperature: 0.3, top_p: 0.5 },
+    High: { temperature: 0.7, top_p: 0.9 },
+    Max: { temperature: 1.0, top_p: 1.0 },
+    Ultra: { temperature: 1.5, top_p: 1.0 },
+};
+export function ensureDirs() {
+    fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+}
+export function loadModels() {
+    ensureDirs();
+    if (!fs.existsSync(MODEL_FILE)) {
+        saveModels(DEFAULT_MODELS);
+        return DEFAULT_MODELS;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(MODEL_FILE, "utf-8"));
+    }
+    catch {
+        return DEFAULT_MODELS;
+    }
+}
+export function saveModels(data) {
+    ensureDirs();
+    fs.writeFileSync(MODEL_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+export function loadConfig() {
+    ensureDirs();
+    if (!fs.existsSync(CONFIG_FILE)) {
+        saveConfig(DEFAULT_CONFIG);
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(data) {
+    ensureDirs();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+export function getModelsByProvider() {
+    const data = loadModels();
+    const result = {};
+    for (const provider of data.providers ?? []) {
+        result[provider.name] = provider.models ?? [];
+    }
+    return result;
+}
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens) {
+    ensureDirs();
+    const now = new Date();
+    const id = sessionId ?? now.toISOString().replace(/[:.]/g, "-");
+    const existing = sessionId ? loadSession(sessionId) : null;
+    const created_at = existing ? existing.created_at : now.toISOString();
+    let title = "";
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            title = (msg.content ?? "").slice(0, 80);
+            break;
+        }
+    }
+    const session = {
+        id,
+        created_at,
+        updated_at: now.toISOString(),
+        model: modelName,
+        provider,
+        intensity,
+        cwd: cwd ?? process.cwd(),
+        title,
+        messages,
+        tokens,
+    };
+    const filePath = path.join(SESSION_DIR, `${id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    return id;
+}
+export function loadSession(sessionId) {
+    const filePath = path.join(SESSION_DIR, `${sessionId}.json`);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteSession(sessionId) {
+    const filePath = path.join(SESSION_DIR, `${sessionId}.json`);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    return false;
+}
+export function listSessions() {
+    ensureDirs();
+    const sessions = [];
+    let files = [];
+    try {
+        files = fs.readdirSync(SESSION_DIR).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return sessions;
+    }
+    for (const f of files) {
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, f), "utf-8"));
+            sessions.push({
+                id: data.id ?? f.replace(/\.json$/, ""),
+                created_at: data.created_at ?? "",
+                updated_at: data.updated_at ?? data.created_at ?? "",
+                model: data.model ?? "",
+                provider: data.provider ?? "",
+                intensity: data.intensity ?? "",
+                cwd: data.cwd ?? "",
+                title: data.title ?? "",
+                message_count: (data.messages ?? []).length,
+            });
+        }
+        catch {
+            // ignore unreadable sessions
+        }
+    }
+    sessions.sort((a, b) => (b.updated_at || b.created_at).localeCompare(a.updated_at || a.created_at));
+    return sessions;
+}
+function readAsset(...candidates) {
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate)) {
+                return fs
+                    .readFileSync(candidate, "utf-8")
+                    .replace(/\r\n/g, "\n")
+                    .replace(/\r/g, "\n");
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return null;
+}
+export function loadLogo() {
+    return (readAsset(path.join(PKG_ROOT, "logo.txt"), path.join(PKG_ROOT, "assets", "logo.txt")) ?? "NEUTRINO");
+}
+export function loadPrompt() {
+    return (readAsset(path.join(PKG_ROOT, "assets", "prompt.txt"), path.join(PKG_ROOT, "prompt.txt")) ??
+        "You are Neutrino, a helpful AI coding assistant.");
+}

package/dist/header.js

@@ -0,0 +1,15 @@
+import { C } from "./colors.js";
+import { truncateByWidth } from "./width.js";
+export function drawHeader(buf, state) {
+    const w = buf.width;
+    buf.fillRect(0, 0, w, 1, { bg: C.highlightBg });
+    let text;
+    if (state.isThinking) {
+        text = "thinking";
+    }
+    else {
+        text = `${state.selectedProvider}/${state.selectedModelName} | ${state.selectedIntensity}`;
+    }
+    text = truncateByWidth(text, w);
+    buf.centerText(0, text, { fg: C.accent, bg: C.highlightBg, bold: true });
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { App } from "./app.js";
+export { defaultState } from "./state.js";
+export { INTENSITY_LEVELS, INTENSITY_PARAMS, DEFAULT_MODELS, loadModels, saveModels, loadConfig, saveConfig, listSessions, loadSession, deleteSession, saveSession, } from "./config.js";
+export { LLMClient } from "./llm/client.js";
+export { executeTool, getToolDefinitions } from "./llm/tools.js";

package/dist/llm/client.js

@@ -0,0 +1,205 @@
+import { INTENSITY_PARAMS } from "../config.js";
+export class LLMClient {
+    model;
+    provider;
+    intensity;
+    temperature;
+    top_p;
+    toolCalls = [];
+    usage = null;
+    constructor(model, provider, intensity) {
+        this.model = model;
+        this.provider = provider;
+        this.intensity = intensity;
+        const params = INTENSITY_PARAMS[intensity] ?? INTENSITY_PARAMS["High"];
+        this.temperature = params.temperature;
+        this.top_p = params.top_p;
+    }
+    async *streamTurn(messages, tools) {
+        this.toolCalls = [];
+        this.usage = null;
+        try {
+            if (this.provider === "Anthropic") {
+                yield* this.streamAnthropic(messages);
+                return;
+            }
+            yield* this.streamOpenAI(messages, tools);
+        }
+        catch (e) {
+            yield `\n[Error: ${e instanceof Error ? e.message : String(e)}]`;
+        }
+    }
+    async *streamOpenAI(messages, tools) {
+        const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.model.api_key}`,
+        };
+        const payload = {
+            model: this.model.name,
+            messages,
+            temperature: this.temperature,
+            top_p: this.top_p,
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (tools && tools.length)
+            payload.tools = tools;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            yield `\n[Error: HTTP ${resp.status}${text ? " - " + text.slice(0, 500) : ""}]`;
+            return;
+        }
+        if (!resp.body) {
+            yield "\n[Error: empty response body]";
+            return;
+        }
+        const toolCallsByIndex = {};
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let stopped = false;
+        while (!stopped) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const raw = buf.slice(0, idx).replace(/\r$/, "");
+                buf = buf.slice(idx + 1);
+                const line = raw.trim();
+                if (!line)
+                    continue;
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trim();
+                if (data === "[DONE]") {
+                    stopped = true;
+                    break;
+                }
+                let chunk;
+                try {
+                    chunk = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const usage = chunk.usage;
+                if (usage) {
+                    this.usage = {
+                        prompt: usage.prompt_tokens ?? 0,
+                        completion: usage.completion_tokens ?? 0,
+                        total: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
+                    };
+                }
+                const choice = chunk.choices?.[0];
+                const delta = choice?.delta ?? {};
+                const content = delta.content;
+                if (typeof content === "string" && content)
+                    yield content;
+                const toolCalls = delta.tool_calls;
+                if (toolCalls) {
+                    for (const tc of toolCalls) {
+                        const i = tc.index ?? 0;
+                        const entry = (toolCallsByIndex[i] ??= { id: "", name: "", arguments: "" });
+                        if (tc.id)
+                            entry.id = tc.id;
+                        if (tc.function?.name)
+                            entry.name = tc.function.name;
+                        if (tc.function?.arguments)
+                            entry.arguments += tc.function.arguments;
+                    }
+                }
+            }
+        }
+        this.toolCalls = Object.keys(toolCallsByIndex)
+            .map((k) => Number(k))
+            .sort((a, b) => a - b)
+            .map((k) => toolCallsByIndex[k]);
+    }
+    async *streamAnthropic(messages) {
+        const url = this.model.url.replace(/\/+$/, "") + "/messages";
+        const headers = {
+            "Content-Type": "application/json",
+            "x-api-key": this.model.api_key,
+            "anthropic-version": "2023-06-01",
+        };
+        let systemMsg;
+        const chatMessages = [];
+        for (const m of messages) {
+            if (m.role === "system")
+                systemMsg = m.content ?? "";
+            else
+                chatMessages.push({ role: m.role, content: m.content ?? "" });
+        }
+        const payload = {
+            model: this.model.name,
+            messages: chatMessages,
+            max_tokens: 4096,
+            temperature: this.temperature,
+            stream: true,
+        };
+        if (systemMsg)
+            payload.system = systemMsg;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            yield `\n[Error: HTTP ${resp.status}${text ? " - " + text.slice(0, 500) : ""}]`;
+            return;
+        }
+        if (!resp.body) {
+            yield "\n[Error: empty response body]";
+            return;
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let stopped = false;
+        while (!stopped) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const raw = buf.slice(0, idx).replace(/\r$/, "");
+                buf = buf.slice(idx + 1);
+                const line = raw.trim();
+                if (!line || !line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trim();
+                if (data === "[DONE]") {
+                    stopped = true;
+                    break;
+                }
+                let chunk;
+                try {
+                    chunk = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const type = chunk.type;
+                if (type === "content_block_delta") {
+                    const text = chunk.delta?.text;
+                    if (text)
+                        yield text;
+                }
+                else if (type === "message_stop") {
+                    stopped = true;
+                    break;
+                }
+            }
+        }
+    }
+}

package/dist/llm/tools.js

@@ -0,0 +1,169 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+const MAX_OUTPUT = 20000;
+const MAX_FILE_SIZE = 200000;
+export function getToolDefinitions() {
+    return [
+        {
+            type: "function",
+            function: {
+                name: "run_command",
+                description: "Execute a shell command in the current working directory and return its stdout/stderr.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        command: { type: "string", description: "The shell command to execute." },
+                    },
+                    required: ["command"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: "read_file",
+                description: "Read the content of a text file. Returns the file content or an error.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to the file to read (absolute or relative to cwd)." },
+                    },
+                    required: ["path"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: "write_file",
+                description: "Write content to a file, creating or overwriting it.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to the file to write (absolute or relative to cwd)." },
+                        content: { type: "string", description: "The full content to write to the file." },
+                    },
+                    required: ["path", "content"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: "list_files",
+                description: "List files and directories in a directory.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Directory to list (defaults to current working directory)." },
+                    },
+                    required: [],
+                },
+            },
+        },
+    ];
+}
+export async function executeTool(name, args) {
+    let result;
+    try {
+        switch (name) {
+            case "run_command":
+                result = await runCommand(String(args.command ?? ""));
+                break;
+            case "read_file":
+                result = readFile(String(args.path ?? ""));
+                break;
+            case "write_file":
+                result = writeFile(String(args.path ?? ""), String(args.content ?? ""));
+                break;
+            case "list_files":
+                result = listFiles(String(args.path ?? ""));
+                break;
+            default:
+                result = `[Error: unknown tool '${name}']`;
+        }
+    }
+    catch (e) {
+        result = `[Error: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    return result.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function runCommand(command) {
+    return new Promise((resolve) => {
+        if (!command.trim()) {
+            resolve("[Error: empty command]");
+            return;
+        }
+        exec(command, { cwd: process.cwd(), timeout: 120000, maxBuffer: MAX_OUTPUT * 4 }, (error, stdout, stderr) => {
+            const parts = [];
+            if (stdout)
+                parts.push(stdout);
+            if (stderr)
+                parts.push("[stderr]\n" + stderr);
+            if (error) {
+                const code = error.code;
+                if (code === "ETIMEDOUT" || error.killed) {
+                    parts.push("[Error: command timed out]");
+                }
+                else {
+                    const exitCode = error.code;
+                    parts.push(`[exit code: ${exitCode ?? "unknown"}]`);
+                }
+            }
+            const output = parts.join("\n").trim();
+            resolve(output ? output.slice(0, MAX_OUTPUT) : "(no output)");
+        });
+    });
+}
+function readFile(p) {
+    const resolved = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
+    if (!fs.existsSync(resolved))
+        return `[Error: file not found: ${resolved}]`;
+    if (fs.statSync(resolved).isDirectory())
+        return `[Error: ${resolved} is a directory]`;
+    try {
+        let data = fs.readFileSync(resolved, "utf-8");
+        if (data.length > MAX_FILE_SIZE)
+            data = data.slice(0, MAX_FILE_SIZE) + "\n...[truncated]";
+        return data;
+    }
+    catch (e) {
+        return `[Error: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+}
+function writeFile(p, content) {
+    const resolved = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
+    try {
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        fs.writeFileSync(resolved, content, "utf-8");
+        return `Wrote ${content.length} characters to ${resolved}`;
+    }
+    catch (e) {
+        return `[Error: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+}
+function listFiles(p) {
+    const resolved = p.trim()
+        ? path.isAbsolute(p)
+            ? p
+            : path.join(process.cwd(), p)
+        : process.cwd();
+    if (!fs.existsSync(resolved))
+        return `[Error: directory not found: ${resolved}]`;
+    if (!fs.statSync(resolved).isDirectory())
+        return `[Error: ${resolved} is not a directory]`;
+    try {
+        const entries = fs
+            .readdirSync(resolved)
+            .map((name) => {
+            const isDir = fs.statSync(path.join(resolved, name)).isDirectory();
+            return name + (isDir ? "/" : "");
+        })
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        return entries.join("\n") || "(empty directory)";
+    }
+    catch (e) {
+        return `[Error: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+}

package/dist/screens/agentConversation.js

@@ -0,0 +1,98 @@
+import { Screen } from "../terminal/screen.js";
+import { C } from "../colors.js";
+import { drawHeader } from "../header.js";
+import { wrapText } from "../ui.js";
+import { ellipsize } from "../width.js";
+export class AgentConversationScreen extends Screen {
+    title;
+    messages;
+    scrollTop = 0;
+    followBottom = true;
+    constructor(title, messages) {
+        super();
+        this.title = title;
+        this.messages = messages;
+    }
+    onKey(key) {
+        if (key.name === "up") {
+            this.followBottom = false;
+            this.scrollTop = Math.max(0, this.scrollTop - 1);
+            this.app.render();
+        }
+        else if (key.name === "down") {
+            this.scrollTop += 1;
+            this.app.render();
+        }
+        else if (key.name === "pageup") {
+            this.followBottom = false;
+            this.scrollTop = Math.max(0, this.scrollTop - 10);
+            this.app.render();
+        }
+        else if (key.name === "pagedown") {
+            this.scrollTop += 10;
+            this.app.render();
+        }
+        else if (key.name === "escape") {
+            this.app.popScreen();
+        }
+    }
+    onMouse(ev) {
+        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();
+        }
+    }
+    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 === "user") {
+                lines.push({ text: "You:", style: { fg: C.accent, bold: true } });
+                push(m.content, { fg: C.user });
+                lines.push({ text: "", style: {} });
+            }
+            else {
+                lines.push({ text: "Assistant:", style: { fg: C.accent, bold: true } });
+                push(m.content, { fg: C.assistant });
+                lines.push({ text: "", style: {} });
+            }
+        }
+        return lines;
+    }
+    render(buf) {
+        drawHeader(buf, this.app.state);
+        const w = buf.width;
+        const h = buf.height;
+        buf.centerText(1, ellipsize(this.title, Math.max(10, w - 4)), { fg: C.dim });
+        const logTop = 3;
+        const logBottom = h - 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);
+        }
+        buf.centerText(h - 1, "↑/↓ scroll  ·  Esc back", { fg: C.dim });
+    }
+}