@xingjisoft/neutrino 0.1.0

package/dist/agents.js

@@ -0,0 +1,396 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+const HOME = os.homedir();
+function parseJsonlLines(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const v = JSON.parse(t);
+            if (v && typeof v === "object")
+                out.push(v);
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return out;
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => {
+            if (typeof b === "string")
+                return b;
+            if (b && typeof b === "object" && typeof b.text === "string") {
+                return b.text;
+            }
+            return "";
+        })
+            .join("");
+    }
+    return "";
+}
+function iso(ms) {
+    const n = typeof ms === "number" ? ms : typeof ms === "string" ? Number(ms) : 0;
+    if (!Number.isFinite(n) || n <= 0)
+        return "";
+    return new Date(n).toISOString();
+}
+function cleanTitle(s) {
+    return s
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/ {2,}/g, " ")
+        .trim();
+}
+// ---------------- Claude Code ----------------
+function claudeProjectDirs() {
+    const base = path.join(HOME, ".claude", "projects");
+    let entries;
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((e) => e.isDirectory()).map((e) => path.join(base, e.name));
+}
+function claudeTitle(lines) {
+    for (const o of lines) {
+        if (o.type === "user") {
+            const t = contentText(o.message?.content).trim();
+            if (t)
+                return t;
+        }
+    }
+    return "";
+}
+function listClaude() {
+    const metas = [];
+    for (const dir of claudeProjectDirs()) {
+        let files;
+        try {
+            files = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".jsonl"))
+                continue;
+            const fp = path.join(dir, f);
+            let st;
+            try {
+                st = fs.statSync(fp);
+            }
+            catch {
+                continue;
+            }
+            const id = f.slice(0, -".jsonl".length);
+            const title = cleanTitle(claudeTitle(parseJsonlLines(fp)) || id.slice(0, 8));
+            metas.push({
+                id,
+                title: title.slice(0, 80),
+                created_at: iso(st.birthtimeMs ?? st.mtimeMs),
+                updated_at: iso(st.mtimeMs),
+                model: "",
+            });
+        }
+    }
+    metas.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    return metas;
+}
+function loadClaude(id) {
+    for (const dir of claudeProjectDirs()) {
+        const fp = path.join(dir, `${id}.jsonl`);
+        if (!fs.existsSync(fp))
+            continue;
+        const out = [];
+        for (const o of parseJsonlLines(fp)) {
+            if (o.type === "user") {
+                const t = contentText(o.message?.content).trim();
+                if (t)
+                    out.push({ role: "user", content: t });
+            }
+            else if (o.type === "assistant") {
+                const t = contentText(o.message?.content).trim();
+                if (t)
+                    out.push({ role: "assistant", content: t });
+            }
+        }
+        return out;
+    }
+    return [];
+}
+// ---------------- Codex ----------------
+function codexIndex() {
+    const map = new Map();
+    const idx = path.join(HOME, ".codex", "session_index.jsonl");
+    for (const o of parseJsonlLines(idx)) {
+        if (typeof o.id === "string" && o.id) {
+            map.set(o.id, {
+                title: typeof o.thread_name === "string" ? o.thread_name : "",
+                updated_at: typeof o.updated_at === "string" ? o.updated_at : "",
+            });
+        }
+    }
+    return map;
+}
+function codexRolloutId(filename) {
+    const m = filename.match(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/);
+    return m ? m[1] : null;
+}
+function codexRolloutFiles() {
+    const map = new Map();
+    const roots = [
+        path.join(HOME, ".codex", "sessions"),
+        path.join(HOME, ".codex", "archived_sessions"),
+    ];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(p);
+            }
+            else if (e.name.endsWith(".jsonl")) {
+                const id = codexRolloutId(e.name);
+                if (!id)
+                    continue;
+                const prev = map.get(id);
+                if (!prev) {
+                    map.set(id, p);
+                    continue;
+                }
+                let pm = 0;
+                let cm = 0;
+                try {
+                    pm = fs.statSync(prev).mtimeMs;
+                }
+                catch { }
+                try {
+                    cm = fs.statSync(p).mtimeMs;
+                }
+                catch { }
+                if (cm > pm)
+                    map.set(id, p);
+            }
+        }
+    };
+    for (const r of roots)
+        walk(r);
+    return map;
+}
+function codexMessageText(payload) {
+    if (payload.role !== "user" && payload.role !== "assistant")
+        return "";
+    const content = payload.content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((c) => {
+        if (c && typeof c === "object" && typeof c.text === "string") {
+            return c.text;
+        }
+        return "";
+    })
+        .join("")
+        .trim();
+}
+function listCodex() {
+    const index = codexIndex();
+    const files = codexRolloutFiles();
+    const metas = [];
+    for (const [id, fp] of files) {
+        const info = index.get(id);
+        let title = info?.title ?? "";
+        let updated = info?.updated_at ?? "";
+        if (!updated) {
+            try {
+                updated = iso(fs.statSync(fp).mtimeMs);
+            }
+            catch { }
+        }
+        if (!title) {
+            for (const o of parseJsonlLines(fp)) {
+                if (o.type === "response_item") {
+                    const t = codexMessageText(o.payload ?? {});
+                    if (t) {
+                        title = t;
+                        break;
+                    }
+                }
+            }
+            if (!title)
+                title = id.slice(0, 8);
+        }
+        metas.push({
+            id,
+            title: cleanTitle(title).slice(0, 80),
+            created_at: updated,
+            updated_at: updated,
+            model: "",
+        });
+    }
+    metas.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    return metas;
+}
+function loadCodex(id) {
+    const files = codexRolloutFiles();
+    const fp = files.get(id);
+    if (!fp)
+        return [];
+    const out = [];
+    for (const o of parseJsonlLines(fp)) {
+        if (o.type !== "response_item")
+            continue;
+        const payload = o.payload ?? {};
+        if (payload.type !== "message")
+            continue;
+        const role = payload.role;
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const text = codexMessageText(payload);
+        if (text)
+            out.push({ role, content: text });
+    }
+    return out;
+}
+// ---------------- OpenCode ----------------
+function opencodeDataDir() {
+    const candidates = [];
+    if (process.env.XDG_DATA_HOME) {
+        candidates.push(path.join(process.env.XDG_DATA_HOME, "opencode"));
+    }
+    candidates.push(path.join(HOME, ".local", "share", "opencode"));
+    candidates.push(path.join(HOME, "Library", "Application Support", "opencode"));
+    for (const c of candidates) {
+        if (fs.existsSync(path.join(c, "opencode.db")))
+            return c;
+    }
+    return null;
+}
+let opencodeDb = null;
+function opencodeDbHandle() {
+    if (opencodeDb)
+        return opencodeDb;
+    const dir = opencodeDataDir();
+    if (!dir)
+        return null;
+    try {
+        process.env.NODE_NO_WARNINGS = "1";
+        const req = createRequire(import.meta.url);
+        const { DatabaseSync } = req("node:sqlite");
+        opencodeDb = new DatabaseSync(path.join(dir, "opencode.db"), { readOnly: true });
+        return opencodeDb;
+    }
+    catch {
+        return null;
+    }
+}
+function opencodeModelName(modelJson) {
+    if (typeof modelJson !== "string" || !modelJson)
+        return "";
+    try {
+        const m = JSON.parse(modelJson);
+        const id = m.id ?? "";
+        const pid = m.providerID ?? m.provider ?? "";
+        return pid && id ? `${pid}/${id}` : id;
+    }
+    catch {
+        return "";
+    }
+}
+function listOpencode() {
+    const db = opencodeDbHandle();
+    if (!db)
+        return [];
+    try {
+        const rows = db
+            .prepare("SELECT id, title, agent, model, time_created, time_updated FROM session ORDER BY time_updated DESC")
+            .all();
+        return rows.map((r) => ({
+            id: String(r.id ?? ""),
+            title: cleanTitle(typeof r.title === "string" ? r.title : "").slice(0, 80),
+            created_at: iso(r.time_created),
+            updated_at: iso(r.time_updated),
+            model: opencodeModelName(r.model) || (typeof r.agent === "string" ? r.agent : ""),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function loadOpencode(id) {
+    const db = opencodeDbHandle();
+    if (!db)
+        return [];
+    try {
+        const msgs = db.prepare("SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created, id").all(id);
+        const out = [];
+        for (const m of msgs) {
+            let data;
+            try {
+                data = JSON.parse(m.data);
+            }
+            catch {
+                continue;
+            }
+            if (data.role !== "user" && data.role !== "assistant")
+                continue;
+            const parts = db.prepare("SELECT data FROM part WHERE message_id = ? ORDER BY time_created, id").all(m.id);
+            let text = "";
+            for (const pr of parts) {
+                let pd;
+                try {
+                    pd = JSON.parse(pr.data);
+                }
+                catch {
+                    continue;
+                }
+                if (pd.type === "text" && typeof pd.text === "string")
+                    text += pd.text;
+            }
+            if (text.trim())
+                out.push({ role: data.role, content: text.trim() });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------- Public API ----------------
+export function listAgentSessions(agent) {
+    if (agent === "claude")
+        return listClaude();
+    if (agent === "codex")
+        return listCodex();
+    return listOpencode();
+}
+export function loadAgentMessages(agent, id) {
+    if (agent === "claude")
+        return loadClaude(id);
+    if (agent === "codex")
+        return loadCodex(id);
+    return loadOpencode(id);
+}

package/dist/app.js

@@ -0,0 +1,169 @@
+import process from "node:process";
+import { Buffer } from "./terminal/buffer.js";
+import { InputReader } from "./terminal/input.js";
+import { Renderer } from "./terminal/renderer.js";
+import { defaultState } from "./state.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { ChatScreen } from "./screens/chat.js";
+import { HistoryScreen } from "./screens/history.js";
+import { AgentSelectScreen } from "./screens/agentSelect.js";
+import { ModelSelectScreen } from "./screens/modelSelect.js";
+import { SettingsScreen } from "./screens/settings.js";
+import { StartScreen } from "./screens/start.js";
+export class App {
+    state = defaultState();
+    width;
+    height;
+    screens = [];
+    renderer = new Renderer();
+    input = new InputReader();
+    running = false;
+    sizeTimer = null;
+    resizeHandler = () => this.onResize();
+    constructor() {
+        this.width = process.stdout.columns || 80;
+        this.height = process.stdout.rows || 24;
+        this.restoreSelection();
+    }
+    readSize() {
+        return {
+            width: process.stdout.columns || 80,
+            height: process.stdout.rows || 24,
+        };
+    }
+    syncSize() {
+        const size = this.readSize();
+        if (size.width !== this.width || size.height !== this.height) {
+            this.width = size.width;
+            this.height = size.height;
+            return true;
+        }
+        return false;
+    }
+    restoreSelection() {
+        const config = loadConfig();
+        this.state.selectedProvider = String(config.selected_provider ?? this.state.selectedProvider);
+        this.state.selectedModelName = String(config.selected_model ?? this.state.selectedModelName);
+        this.state.selectedIntensity = String(config.selected_intensity ?? this.state.selectedIntensity);
+        this.state.selectedModelUrl = String(config.selected_model_url ?? this.state.selectedModelUrl);
+        this.state.selectedModelApiKey = String(config.selected_model_api_key ?? this.state.selectedModelApiKey);
+        this.state.selectedModelStreaming = Boolean(config.selected_model_streaming ?? true);
+    }
+    async start() {
+        this.renderer.init();
+        this.input.start((ev) => this.handleEvent(ev));
+        process.stdout.on("resize", this.resizeHandler);
+        process.on("SIGINT", () => this.quit());
+        process.on("SIGTERM", () => this.quit());
+        this.sizeTimer = setInterval(() => {
+            if (this.syncSize())
+                this.render();
+        }, 200);
+        this.pushScreen(new StartScreen());
+    }
+    onResize() {
+        if (this.syncSize())
+            this.render();
+    }
+    get top() {
+        return this.screens[this.screens.length - 1];
+    }
+    pushScreen(screen) {
+        screen.app = this;
+        this.screens.push(screen);
+        screen.onActivate();
+        this.render();
+    }
+    popScreen() {
+        const screen = this.screens.pop();
+        screen?.onDeactivate();
+        this.render();
+    }
+    render() {
+        const buf = new Buffer(this.width, this.height);
+        this.top?.render(buf);
+        this.renderer.render(buf);
+    }
+    handleEvent(ev) {
+        if (ev.type === "key") {
+            const k = ev.key;
+            if (k.ctrl && (k.name === "c" || k.name === "q")) {
+                this.quit();
+                return;
+            }
+            if (k.ctrl && (k.name === "m" || k.name === "e")) {
+                this.openModelConfig();
+                return;
+            }
+            this.top?.onKey(k);
+        }
+        else {
+            this.top?.onMouse(ev.event);
+        }
+    }
+    setModelConfig(providerName, model, intensity) {
+        this.state.selectedProvider = providerName;
+        this.state.selectedModelName = model.name;
+        this.state.selectedModelUrl = model.url;
+        this.state.selectedModelApiKey = model.api_key ?? "";
+        this.state.selectedModelStreaming = model.supports_streaming ?? true;
+        this.state.selectedIntensity = intensity;
+        const config = loadConfig();
+        config.selected_provider = providerName;
+        config.selected_model = model.name;
+        config.selected_intensity = intensity;
+        config.selected_model_url = model.url;
+        config.selected_model_api_key = model.api_key ?? "";
+        config.selected_model_streaming = model.supports_streaming ?? true;
+        saveConfig(config);
+    }
+    startNewChat(text) {
+        this.pushScreen(new ChatScreen(text));
+    }
+    loadSession(data) {
+        const screen = new ChatScreen("");
+        screen.sessionId = data.id;
+        screen.loadedMessages = data.messages ?? [];
+        screen.loadedProvider = data.provider || null;
+        screen.loadedModel = data.model || null;
+        screen.loadedIntensity = data.intensity || null;
+        screen.loadedTokens = data.tokens ?? null;
+        if (data.provider)
+            this.state.selectedProvider = data.provider;
+        if (data.model)
+            this.state.selectedModelName = data.model;
+        if (data.intensity)
+            this.state.selectedIntensity = data.intensity;
+        this.pushScreen(screen);
+    }
+    openModelConfig() {
+        if (this.screens.some((s) => s instanceof ModelSelectScreen))
+            return;
+        this.pushScreen(new ModelSelectScreen());
+    }
+    openHistory() {
+        if (this.screens.some((s) => s instanceof HistoryScreen))
+            return;
+        this.pushScreen(new HistoryScreen());
+    }
+    openAgentSelect() {
+        if (this.screens.some((s) => s instanceof AgentSelectScreen))
+            return;
+        this.pushScreen(new AgentSelectScreen());
+    }
+    openSettings() {
+        if (this.screens.some((s) => s instanceof SettingsScreen))
+            return;
+        this.pushScreen(new SettingsScreen());
+    }
+    quit() {
+        if (this.running)
+            return;
+        this.running = true;
+        if (this.sizeTimer)
+            clearInterval(this.sizeTimer);
+        this.input.stop();
+        this.renderer.dispose();
+        process.exit(0);
+    }
+}

package/dist/bin.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { App } from "./app.js";
+if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    process.stderr.write("neutrino requires an interactive terminal.\n");
+    process.exit(1);
+}
+const app = new App();
+await app.start();

package/dist/colors.js

@@ -0,0 +1,14 @@
+export const C = {
+    accent: [153, 217, 234], // #99D9EA
+    highlightBg: [40, 57, 61], // #28393D
+    black: [0, 0, 0],
+    dim: [86, 95, 137], // #565F89
+    user: [169, 177, 214], // #A9B1D6
+    assistant: [192, 202, 245], // #C0CAF5
+    toolHeader: [153, 217, 234], // cyan
+    amber: [224, 175, 104], // #E0AF68
+    white: [226, 232, 240],
+    green: [115, 218, 202],
+    red: [247, 118, 142],
+};
+export const EMPTY_STYLE = {};