@xingjisoft/neutrino 0.6.0 → 0.7.0

package/dist/pro/config.d.ts

@@ -0,0 +1,75 @@
+import { type ModelInfo } from "../config.js";
+/** Provider URLs and credentials stay in the shared, ordinary model catalogue. */
+export declare const PRO_MODEL_FILE: string;
+/** Presets the user adds or rewrites themselves; a same-named preset here wins. */
+export declare const PRO_CUSTOM_MODEL_FILE: string;
+/** The official presets, fetched on first use: nothing is bundled with the package. */
+export declare const PRO_MODELS_URL = "https://ius.neutrino.xingjisoft.com/model.json";
+export declare const PRO_ROLES: readonly ["main_model", "thinking_model", "front_output_model", "backend_output_model", "confirm_model", "genimage_model", "plan_model", "modeling_model"];
+export type ProRole = (typeof PRO_ROLES)[number];
+export declare const ACTIVE_PRO_ROLES: ("confirm_model" | "main_model" | "thinking_model" | "front_output_model" | "backend_output_model" | "plan_model" | "modeling_model")[];
+export declare const PRO_ROLE_LABELS: Record<ProRole, string>;
+export interface ProModelSetting {
+    type: ProRole;
+    provider: string;
+    model: string | null;
+    intensity: string;
+    context_window: number;
+}
+export interface ProPreset {
+    name: string;
+    chinese_name: string;
+    "model-setting": ProModelSetting[];
+}
+export interface ProModelsData {
+    tier: ProPreset[];
+}
+/** Contains credentials. Never send this shape over the public API. */
+export interface ProResolvedModel {
+    role: ProRole;
+    provider: string;
+    model: ModelInfo;
+    intensity: string;
+    context_window: number;
+    tier: string;
+}
+export interface ProModelReference {
+    provider: string;
+    model: string;
+    tier: string;
+}
+export interface ProFallback {
+    role: ProRole;
+    requested: ProModelReference;
+    replacement: ProModelReference | null;
+    reason: string;
+}
+export interface ProModelSyncResult {
+    /** `updated`: the official copy replaced the file. `unchanged`: they agree. */
+    status: "updated" | "unchanged" | "kept";
+    /** Why the local presets were kept, when the official copy could not be used. */
+    detail?: string;
+}
+/**
+ * Make sure the Pro presets are on disk, downloading the official set the first
+ * time. A file the user already has is never touched here; a failed download
+ * leaves nothing behind, so the next start simply tries again.
+ */
+export declare function ensureProModels(): Promise<void>;
+/**
+ * Keep ~/.neutrino/pro/model.json in step with the official presets, which own
+ * that file: any difference is overwritten. Presets the user keeps for
+ * themselves belong in model-custom.json, so nothing personal is lost. When the
+ * official copy cannot be read, the local presets stay exactly as they are.
+ *
+ * Called once at start-up by both the terminal and the Web console.
+ */
+export declare function syncProModels(): Promise<ProModelSyncResult>;
+export declare function loadProModels(): ProModelsData;
+export declare function requireProPreset(value: unknown): string;
+export declare function defaultProPreset(): string;
+export declare const DEFAULT_PRO_RECURSION_DEPTH = 10;
+export declare const MAX_PRO_RECURSION_DEPTH = 100;
+export declare function proMaxRecursionDepth(): number;
+/** Every agent prompt lives in the requested assets/pro directory. */
+export declare function loadProPrompt(role: ProRole): string;

package/dist/pro/config.js

@@ -1,3 +1,4 @@
+import { pluginPrompt } from "../plugins/session.js";
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
@@ -213,6 +214,6 @@ export function proMaxRecursionDepth() {
 export function loadProPrompt(role) {
     if (!PRO_ROLES.includes(role))
         throw new Error("Unknown Pro role");
-    return fs.readFileSync(path.join(ASSET_DIR, "common.txt"), "utf8") + "\n\n" +
-        fs.readFileSync(path.join(ASSET_DIR, `${role}.txt`), "utf8");
+    return pluginPrompt(fs.readFileSync(path.join(ASSET_DIR, "common.txt"), "utf8") + "\n\n" +
+        fs.readFileSync(path.join(ASSET_DIR, `${role}.txt`), "utf8"), role);
 }

package/dist/pro/preflight.d.ts

@@ -0,0 +1,21 @@
+import { type UsageInfo } from "../llm/client.js";
+import { type ProFallback, type ProResolvedModel, type ProRole } from "./config.js";
+export interface ProPreflightResult {
+    models: Partial<Record<ProRole, ProResolvedModel>>;
+    fallbacks: ProFallback[];
+}
+export declare class ProPreflightError extends Error {
+    readonly fallbacks: ProFallback[];
+    constructor(message: string, fallbacks: ProFallback[]);
+}
+export interface ProPreflightOptions {
+    signal?: AbortSignal;
+    onUsage?(usage: UsageInfo): void;
+    /** Bounded for each actual inference, including its response body. */
+    timeoutMs?: number;
+}
+/**
+ * Resolve each job independently, descending only within that job. Neither the
+ * shared catalogue nor the Pro presets are edited by a temporary replacement.
+ */
+export declare function resolveProTeam(presetName: string, options?: ProPreflightOptions): Promise<ProPreflightResult>;

package/dist/sanitize.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Text hygiene for anything that will be drawn into the terminal Buffer.
+ *
+ * The renderer copies a cell's glyph straight into the output stream, so a cell
+ * that somehow holds a *control* character turns into a command the terminal
+ * executes: an ESC sequence can move the cursor, clear the screen or leave the
+ * alternate buffer, and a TAB shifts the rest of the row. Tool output (ANSI
+ * colours from `ls --color`, `git`, `npm`, progress bars, …), file contents and
+ * pasted text routinely carry such bytes, so they must be neutralised before
+ * they can reach the screen.
+ *
+ * `sanitizeText` is the *display-side* cleanup: it removes whole escape
+ * sequences (not just the ESC byte, which would leave `[31m` behind as literal
+ * text), expands tabs so every character's measured width matches what the
+ * terminal will draw, and drops any remaining control code. Newlines are kept
+ * because the wrapping/markdown layer needs them to lay text out.
+ */
+/** Remove ANSI/VT escape sequences from `text`. */
+export declare function stripAnsi(text: string): string;
+export interface SanitizeOptions {
+    /** How many spaces a tab expands to. Defaults to 4. */
+    tabWidth?: number;
+    /** When true, newlines are also collapsed to spaces (for single-line fields
+     *  such as the chat input). Defaults to false. */
+    singleLine?: boolean;
+}
+/**
+ * Make `text` safe to render: normalise newlines, drop escape sequences, expand
+ * tabs and remove every other control code. The result contains no character
+ * the terminal would interpret as a command, so it can never corrupt the grid.
+ */
+export declare function sanitizeText(text: string, opts?: SanitizeOptions): string;
+/** True if `ch` is a character the terminal would treat as a control code. */
+export declare function isControlChar(ch: string): boolean;

package/dist/screens/agentConversation.d.ts

@@ -0,0 +1,28 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen, type ScrollbarHandle } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import type { AgentId, AgentMessage } from "../agents.js";
+interface MigrationSource {
+    agent: AgentId;
+    id: string;
+    cwd: string;
+}
+export declare class AgentConversationScreen extends Screen {
+    private source;
+    private title;
+    private messages;
+    private scrollTop;
+    private followBottom;
+    private scrollbarGeom;
+    private migrateButton;
+    private migrationError;
+    constructor(title: string, messages: AgentMessage[], source: MigrationSource);
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    private migrate;
+    alwaysRepaintRows(): number[];
+    scrollbar(): ScrollbarHandle | null;
+    private buildLines;
+    render(buf: Buffer): void;
+}
+export {};

package/dist/screens/agentHistory.d.ts

@@ -0,0 +1,25 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import { type AgentId } from "../agents.js";
+export declare class AgentHistoryScreen extends Screen {
+    private agent;
+    private label;
+    private sessions;
+    private selectedIdx;
+    private scrollTop;
+    private lastHoverX;
+    private lastHoverY;
+    private rows;
+    private itemBounds;
+    private cwd;
+    constructor(agent: AgentId, label: string);
+    onActivate(): void;
+    private move;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    private itemIndexAtRow;
+    private loadSelected;
+    private buildRows;
+    render(buf: Buffer): void;
+}

package/dist/screens/agentSelect.d.ts

@@ -0,0 +1,16 @@
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+export declare class AgentSelectScreen extends Screen {
+    private selectedIdx;
+    private scrollBtn;
+    private lastHoverX;
+    private lastHoverY;
+    onActivate(): void;
+    private move;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    private indexAtRow;
+    private confirm;
+    render(buf: Buffer): void;
+}

package/dist/screens/chat.d.ts

@@ -0,0 +1,292 @@
+import { type FastSnapshot } from "../fast/types.js";
+import type { Buffer } from "../terminal/buffer.js";
+import { Screen, type ScrollbarHandle } from "../terminal/screen.js";
+import type { Key, MouseEvent } from "../terminal/input.js";
+import { type AgentMode, type ModelInfo, type SessionMessage, type TokenUsage, type ResolvedModelSelection, type ApprovalMode } from "../config.js";
+import { type TaskSnapshot } from "../llm/runtime.js";
+import { type PlanState } from "../llm/plan.js";
+import { type ConversationContext } from "../compact.js";
+import { type LiveAgent, type LiveMeta, type LiveSnapshot, type ModelChangeResult } from "../web/hub.js";
+/** A sub-agent gets the same tools minus delegation: one level, never a tree. */
+/**
+ * A finished turn folds its *work* away — the thinking and the tool calls —
+ * while the full user prompt and final reply always stay on screen. Doing
+ * that is only worth a click when the work is substantial: four or more blocks,
+ * or roughly six wrapped lines of text. Short exchanges stay readable without a
+ * click. `web/turns.js` applies the same rule in the browser, so both UIs fold
+ * exactly the same turns.
+ */
+export declare const TURN_FOLD_MIN_BLOCKS = 4;
+export declare const TURN_FOLD_MIN_CHARS = 600;
+export declare class ChatScreen extends Screen implements LiveAgent {
+    initialMessage: string;
+    loadedMessages: SessionMessage[] | null;
+    loadedCwd: string | null;
+    sessionId: string | null;
+    loadedProvider: string | null;
+    loadedModel: string | null;
+    loadedIntensity: string | null;
+    loadedTokens: TokenUsage | null;
+    loadedContext: ConversationContext | null;
+    loadedApprovalMode: ApprovalMode | null;
+    loadedPlan: PlanState | null;
+    loadedTask: TaskSnapshot | undefined;
+    loadedFast: FastSnapshot | undefined;
+    loadedAgentMode: AgentMode | null;
+    private approvalMode;
+    modelProvider: string;
+    model: ModelInfo;
+    intensity: string;
+    private tokens;
+    private showInfo;
+    /** The plan of the turn being worked on, or the last one. */
+    private plan;
+    /** True while the planner agent is writing the steps. */
+    private planning;
+    /** What the sub-agent is doing, or null when none is running. */
+    private subagent;
+    private messages;
+    private streamingContent;
+    private saveError;
+    /** Why a busy turn is silent: a transient network failure being retried. */
+    private retryNotice;
+    private checkpoint;
+    private busy;
+    private paused;
+    private queued;
+    private taskRuntime;
+    private lastTask;
+    private taskOutcome;
+    private turnToken;
+    private agentMode;
+    private activeAgentMode;
+    private fastState?;
+    private queuedAgentMode;
+    private turnAbort;
+    private inputValue;
+    private cursor;
+    private scrollTop;
+    private followBottom;
+    private scrollbarGeom;
+    private lastEscTime;
+    private initialized;
+    /** Prompt tokens of the most recent request — the best proxy for how large
+     *  the current context has grown. Reset once the history is compressed. */
+    private lastPromptTokens;
+    private compressing;
+    private context;
+    private expandedContext;
+    private contextLines;
+    private contextRows;
+    /** Message indices whose tool output is expanded (everything starts
+     *  collapsed). */
+    private expandedTools;
+    /** For each line produced by buildLines, the tool message index it belongs
+     *  to, or -1 when it is not part of a tool block. */
+    private toolLineIndex;
+    /** Terminal row -> tool message index, rebuilt each render for hit-testing. */
+    private toolRows;
+    /** First message index of every turn whose reply has finished. A transcript
+     *  loaded from disk starts finished: reopening history reviews past work. */
+    private finishedTurns;
+    /** Turns the reader opened; a finished turn stays folded unless listed here. */
+    private expandedTurns;
+    /** First message index of the turn being answered right now, if any. */
+    private activeTurnStart;
+    /** For each built line, the folded turn it belongs to (-1 = none). Only the
+     *  header lines carry it, so clicks inside a tool block still target the tool. */
+    private turnLineIndex;
+    /** Terminal row -> folded turn start, rebuilt each render for hit-testing. */
+    private turnRows;
+    private liveKey;
+    private liveDir;
+    /** Non-null while a tool call is waiting for a human decision. */
+    private approvalQueue;
+    private pendingApproval;
+    private reviewing;
+    /** Decisions taken by the gate, keyed by the tool message (survives
+     * context compression, which renumbers the array). */
+    private approvals;
+    /** Hit boxes of the approval card, rebuilt on every render. */
+    private approvalButtons;
+    constructor(initialMessage?: string);
+    onActivate(): void;
+    onDeactivate(): void;
+    liveCwd(): string;
+    liveConfigure(selection: ResolvedModelSelection): ModelChangeResult;
+    liveMeta(): LiveMeta;
+    liveSnapshot(key: string): LiveSnapshot;
+    livePause(): void;
+    liveResume(): void;
+    /** Answer the pending call from the web UI. */
+    liveApprove(approved: boolean, approvalId?: string): boolean;
+    liveSetAgentMode(mode: AgentMode): ModelChangeResult;
+    liveSetApprovalMode(mode: ApprovalMode): void;
+    /**
+     * Start a fresh conversation in the same working directory. Used by Ctrl+L
+     * and by the browser's Clear button, so both screens behave identically. The
+     * previous transcript is saved first and is never overwritten.
+     */
+    liveClear(): void;
+    liveSend(text: string): void;
+    private liveTitle;
+    private publishLive;
+    private approvalToggleY;
+    /**
+     * The input row is persistent chrome: it is drawn with absolute positioning
+     * and must survive any terminal-side drift (ConPTY reflow, a stray scroll).
+     * Repainting it every frame makes the input area self-healing — the log can
+     * never end up "covering" it.
+     */
+    alwaysRepaintRows(): number[];
+    showsCursor(): boolean;
+    onPaste(text: string): void;
+    onKey(key: Key): void;
+    onMouse(ev: MouseEvent): void;
+    scrollbar(): ScrollbarHandle | null;
+    private togglePause;
+    private maybeFlushQueue;
+    /**
+     * Run the planner agent over the current request.
+     *
+     * Returns null rather than throwing in every case where there is no usable
+     * plan — planning switched off, a one-step request, a provider that fails, an
+     * answer that is not a plan. The turn then runs exactly as it did before
+     * plan-first existed; a plan is an improvement, never a new way to fail.
+     */
+    private makePlan;
+    /** Move the plan to one step and show it: the card follows every transition. */
+    private setStep;
+    /** A turn that can no longer continue must not leave a step looking alive. */
+    private haltPlan;
+    /**
+     * One user turn.
+     *
+     * A planned turn is answered in two passes: the planner writes the steps, then
+     * the worker executes them one at a time, top to bottom, each with the whole
+     * plan in its system prompt and the instruction to do only its own step. That
+     * keeps the work of a long request explicit — the card shows exactly which
+     * step is running and which are done — and keeps every step verifiable on its
+     * own. Without a plan the turn runs in one pass, as before.
+     */
+    private runTurn;
+    private runTaskTurn;
+    /**
+     * The transcript this turn may see: the messages it started with plus what it
+     * has added since — the plan message, replies, tool calls and results.
+     *
+     * A user message that arrives while the turn runs is queued for the *next*
+     * turn, so it is deliberately not part of this one: the model and the approval
+     * reviewers must always judge the same request.
+     */
+    private turnView;
+    private send;
+    private startTurn;
+    /**
+     * Ends a turn that failed before or around the agent loop.
+     *
+     * The turn body is a floating promise, so anything thrown outside the loop's
+     * own try/catch would otherwise surface as an unhandled rejection, which Node
+     * turns into a fatal error. Ending the turn here keeps the app alive and the
+     * failure visible in the transcript.
+     */
+    private failTurn;
+    private runFastTurn;
+    private buildApiMessages;
+    /**
+     * One agent conversation: request, tool calls, request again, until the model
+     * answers without asking for a tool.
+     *
+     * Returns true when the model finished on its own and false when the turn was
+     * cut short (paused, superseded, or failed). The caller owns the turn's end,
+     * because a planned turn runs this once per step.
+     */
+    private agentLoop;
+    /**
+     * Ends the turn. `finished` is false when the turn was cut short (ESC ESC,
+     * Ctrl+C): a paused turn is not a completed one and stays open for reading.
+     */
+    private onTurnFinished;
+    /** Classify a tool call and, when it is risky, run it past the gate. */
+    private requestApproval;
+    /** Park the turn until the user answers; the header turns orange meanwhile. */
+    private askHuman;
+    /** Answer the pending request (keyboard, mouse, or the web UI). */
+    private settleApproval;
+    /** Reviewer model: `approval_model` when set, otherwise the chat model. */
+    private reviewerModel;
+    /** Orange card listing the pending call and its buttons. */
+    private drawApprovalCard;
+    private runProgram;
+    /**
+     * Run one approved tool call. `delegate` is handled here rather than inside
+     * tools.ts: a sub-agent has to share this turn's model, approval gate, working
+     * directory and abort signal, and only the session knows about those.
+     */
+    private runTool;
+    private dispatchTool;
+    /**
+     * Run a sub-agent for one `delegate` call and return its report.
+     *
+     * The child gets its own conversation, the parent's tools (minus delegation)
+     * and the parent's approval gate; what it does in between is deliberately not
+     * part of this transcript. While it runs, its current phase is shown in the
+     * status line and in the tool block, so a quiet log still has an explanation.
+     */
+    private delegate;
+    /** First message index of every turn: a turn starts at a user message and
+     *  ends where the next one begins. */
+    private userMessageIndexes;
+    private turnEnd;
+    /**
+     * A finished turn is only worth folding when the work it hides is substantial.
+     * Whether it is folded right now is a separate question (`expandedTurns`), and
+     * its user input and reply are never part of what it hides.
+     */
+    private turnHides;
+    /**
+     * The index of the turn's reply: its last assistant message. A fold hides the
+     * work that led to the answer, so this message is always rendered.
+     */
+    private turnAnswer;
+    /** For every message, the reply of the turn it belongs to (-1 = none). */
+    private turnAnswers;
+    /** For every message, the first index of the turn folding it (-1 = none). */
+    private turnMap;
+    /** The header standing in for a folded turn, or the way back into one. */
+    private pushTurnHeader;
+    /** Fold or unfold one turn. */
+    private toggleTurn;
+    /** Expand/collapse the tool block belonging to message `index`. */
+    private toggleTool;
+    /** Compress at 80% of the current model's context capacity. */
+    private compressThreshold;
+    /**
+     * Summarise only the model's history. Original messages stay in the transcript
+     * and on disk; the UI folds the summarised prefix until the reader expands it.
+     */
+    private autoCompress;
+    /**
+     * Summarise a transcript produced by `transcriptFor`. Split out so tests can
+     * stub it without touching the network.
+     */
+    protected summarizeTranscript(transcript: string, cancelled?: () => boolean): Promise<string>;
+    /**
+     * Keep the outbound payload within budget during a long single turn: once the
+     * context is over the threshold, blank out all but the most recent tool
+     * results. Their full text stays in the visible log, which is collapsible.
+     */
+    private trimApiMessages;
+    private retainStreamingContent;
+    private save;
+    private writeSession;
+    private buildLines;
+    render(buf: Buffer): void;
+    private renderInfoOverlay;
+    /**
+     * What the card shows: the plan as a vertical timeline, then the token counts.
+     * Without a plan it is exactly the token card it has always been. One row is
+     * kept for the counts, so a long plan cannot push them out of the card.
+     */
+    private infoCardRows;
+}