@otto-code/brain 0.7.5

package/dist/sysmon.js

@@ -0,0 +1,103 @@
+import os from "node:os";
+import http from "node:http";
+import { query } from "./gpu.js";
+/** CPU busy fraction, sampled between successive calls. */
+export function createCpuSampler() {
+    let previous = null;
+    function snapshot() {
+        let idle = 0;
+        let total = 0;
+        for (const cpu of os.cpus()) {
+            for (const [kind, ms] of Object.entries(cpu.times)) {
+                total += ms;
+                if (kind === "idle")
+                    idle += ms;
+            }
+        }
+        return { idle, total };
+    }
+    return function sample() {
+        const now = snapshot();
+        if (!previous) {
+            previous = now;
+            return null; // first call establishes the baseline
+        }
+        const idleDelta = now.idle - previous.idle;
+        const totalDelta = now.total - previous.total;
+        previous = now;
+        if (totalDelta <= 0)
+            return null;
+        return Math.max(0, Math.min(1, 1 - idleDelta / totalDelta));
+    };
+}
+function fetchJson({ host, port, path: urlPath, timeout = 2500, }) {
+    return new Promise((resolve) => {
+        const req = http.get({ host, port, path: urlPath, timeout }, (res) => {
+            let body = "";
+            res.on("data", (c) => (body += c));
+            res.on("end", () => {
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.on("error", () => resolve(null));
+    });
+}
+/**
+ * Slot occupancy from the running server.
+ * @returns {{total:number, busy:number, idle:number, contexts:number[]}|null}
+ */
+async function slots({ host, port }) {
+    const data = await fetchJson({ host, port, path: "/slots" });
+    if (!Array.isArray(data))
+        return null;
+    const rows = data;
+    // Field naming has varied across llama.cpp versions; accept either.
+    const busy = rows.filter((s) => {
+        const rec = s;
+        if (typeof rec.is_processing === "boolean")
+            return rec.is_processing;
+        if (typeof rec.state === "number")
+            return rec.state !== 0;
+        return false;
+    }).length;
+    return {
+        total: rows.length,
+        busy,
+        idle: rows.length - busy,
+        contexts: rows.map((s) => {
+            const rec = s;
+            const nCtx = typeof rec.n_ctx === "number" ? rec.n_ctx : undefined;
+            const nPast = typeof rec.n_past === "number" ? rec.n_past : undefined;
+            return nCtx ?? nPast ?? 0;
+        }),
+    };
+}
+export { slots };
+/** One combined reading for the status panel. */
+export async function sample(sampler, { host, port } = {}) {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const [gpuInfo, slotInfo] = await Promise.all([
+        query(),
+        host && port ? slots({ host, port }) : Promise.resolve(null),
+    ]);
+    return {
+        cpu: sampler(),
+        cpuCount: os.cpus().length,
+        loadAverage: os.loadavg()[0] || null, // 0 on Windows; shown only when real
+        ramUsedBytes: totalMem - freeMem,
+        ramTotalBytes: totalMem,
+        gpu: gpuInfo,
+        slots: slotInfo,
+    };
+}
+//# sourceMappingURL=sysmon.js.map

package/dist/tui/app.d.ts

@@ -0,0 +1,208 @@
+import { Screen } from "./screen.js";
+import type { DiskUsage, QuantOption, RepoQuants, ModelSearchResult } from "../models/index.js";
+import { Supervisor } from "../service/supervisor.js";
+import { Telemetry } from "../service/router.js";
+import http from "node:http";
+import type { GpuInfo, Model, Runtime } from "../types.js";
+import type { Budget } from "../vram.js";
+import type { Calibration, Profile, ProfilesStore } from "../config/schema.js";
+import type { RankedModel, RunRecord } from "../ops/results.js";
+import type { SweepReport } from "../ops/sweep.js";
+import type { CpuSampler, SystemSample } from "../sysmon.js";
+type Tone = "info" | "good" | "warn" | "bad";
+type Focus = "models" | "config";
+type ViewMode = "standard" | "logs" | "help" | "bench";
+/** The model a field's callbacks are rendered against. */
+interface FieldContext {
+    model: Model | null;
+}
+/** A pending destructive action awaiting y/n. */
+interface ConfirmState {
+    kind: "delete";
+    model: Model;
+}
+/** One downloadable quant in the picker, with whether it is already on disk. */
+interface PickerQuant extends QuantOption {
+    installed: boolean;
+}
+/** The quant-download picker: a modal list of a repo's available quants. */
+interface PickerState {
+    model: Model | null;
+    repo: string;
+    loading: boolean;
+    options: PickerQuant[];
+    mmproj: RepoQuants["mmproj"];
+    index: number;
+}
+/** The Hugging Face search modal: type a query, then browse GGUF repos. */
+interface SearchState {
+    query: string;
+    input: boolean;
+    loading: boolean;
+    results: ModelSearchResult[];
+    index: number;
+}
+/** One editable configuration field. */
+interface Field {
+    key: keyof Profile;
+    label: string;
+    kind: "number" | "cycle" | "toggle";
+    format: (profile: Profile, ctx: FieldContext) => string;
+    step?: number;
+    min?: number;
+    max?: number | ((ctx: FieldContext) => number);
+    values?: Array<number | string>;
+    note?: (profile: Profile) => string | null;
+    enabled?: (ctx: FieldContext) => boolean;
+}
+/** The number field currently being typed into. */
+interface EditingState {
+    field: Field;
+    buffer: string;
+}
+/** The current status line and its tone. */
+interface StatusState {
+    text: string;
+    tone: Tone;
+}
+/** Constructor options for the interactive app. */
+interface AppOptions {
+    runtime: Runtime;
+    listenPort: number;
+    listenHost: string;
+}
+/** Editable configuration fields, in display order. */
+export declare const FIELDS: Field[];
+export declare class App {
+    runtime: Runtime;
+    listenPort: number;
+    listenHost: string;
+    screen: Screen;
+    store: ProfilesStore;
+    catalog: Model[];
+    filter: string;
+    selected: number;
+    scrollTop: number;
+    focus: Focus;
+    fieldIndex: number;
+    editing: EditingState | null;
+    busy: boolean;
+    status: StatusState;
+    gpuInfo: GpuInfo | null;
+    profile: Profile | null;
+    sweepResult: SweepReport | null;
+    cpuSampler: CpuSampler;
+    sys: SystemSample | null;
+    viewMode: ViewMode;
+    benchRunning: boolean;
+    benchProgress: string[];
+    benchResults: RunRecord[];
+    benchModelId: string | null;
+    rankings: Map<string, RankedModel>;
+    rankedModels: RankedModel[];
+    telemetry: Telemetry;
+    supervisor: Supervisor;
+    routerServer: http.Server | null;
+    filterMode: boolean;
+    confirming: ConfirmState | null;
+    picker: PickerState | null;
+    search: SearchState | null;
+    disk: DiskUsage | null;
+    detach?: () => void;
+    ticker?: NodeJS.Timeout;
+    done?: () => void;
+    constructor({ runtime, listenPort, listenHost }: AppOptions);
+    run(): Promise<void>;
+    shutdown(): Promise<void>;
+    /** Fit a model to the live VRAM budget and (re)start the server on it. */
+    loadModelFitted(target: Model): Promise<void>;
+    startRouter(): Promise<void>;
+    reload(): void;
+    /** Mean-of-runs rank + score per model, for ordering and badging the list. */
+    loadRankings(): void;
+    rankOf(model: Model | null): RankedModel | null;
+    /** Small, bounded ordering nudge for more-capable models (vision, thinking). */
+    capabilityBonus(model: Model): number;
+    get visible(): Model[];
+    get model(): Model | null;
+    syncProfile(): void;
+    get calibration(): Calibration | null;
+    get budget(): Budget | null;
+    persist(): void;
+    setStatus(text: string, tone?: Tone): void;
+    onKey(key: string): void;
+    onFilterKey(key: string): void;
+    onEditKey(key: string): void;
+    move(delta: number): void;
+    usableFields(): number[];
+    /** Read a profile field by key, without narrowing to a single value type. */
+    readField(key: keyof Profile): unknown;
+    /** Write a profile field by key; a no-op when no model is selected. */
+    writeField(key: keyof Profile, value: number | string | boolean): void;
+    adjust(direction: number): void;
+    activateField(): void;
+    applyMaxContext(): void;
+    /** The Hugging Face repo for a model: catalog match, else the id's first two
+     * path segments (`<publisher>/<repo>/<file>`). */
+    repoOf(model: Model): string | null;
+    refreshDisk(): Promise<void>;
+    beginDelete(): void;
+    onConfirmKey(key: string): void;
+    beginDownload(): Promise<void>;
+    /** Open the quant picker for a repo (an installed model, or one from search). */
+    openPicker(repo: string, model: Model | null): Promise<void>;
+    /** A direct owner/repo the query names, so a known repo can be opened without
+     * a round trip. Null unless the query looks like a repo path. */
+    directRepo(query: string): string | null;
+    beginSearch(): void;
+    onSearchKey(key: string): void;
+    runSearch(): Promise<void>;
+    drawSearch(cols: number): void;
+    onPickerKey(key: string): void;
+    downloadQuant(repo: string, choice: PickerQuant, mmproj: RepoQuants["mmproj"]): Promise<void>;
+    drawPicker(cols: number): void;
+    guard(label: string, fn: () => Promise<void>): Promise<void>;
+    startModel(): Promise<void> | void;
+    stopModel(): Promise<void>;
+    runCalibration(): Promise<void> | void;
+    runSweep(): Promise<void> | void;
+    enterBench(): void;
+    loadBenchResults(): void;
+    onBenchKey(key: string): void;
+    /** Load the selected model if needed, run the suite, and store the result. */
+    runBenchmarkOnSelected(): Promise<void> | void;
+    scoreColour(score: number): string;
+    /**
+     * Render, but never let the footer scroll off. The renderer only paints
+     * rows-1 lines; if the layout is taller than the terminal, drop rows from
+     * just above the footer so the keybindings hint is always on screen.
+     */
+    renderFitted(lines: string[]): void;
+    draw(): void;
+    /**
+     * Benchmark workspace: the model list on the left, the selected model's
+     * scorecard where Configuration sits in serve mode, and the ranked leaderboard
+     * (or live run progress) where the Status panel sits.
+     */
+    drawBench(cols: number): void;
+    /** The selected model's latest scorecard, or a prompt to run one. */
+    benchSidebar(innerWidth: number, rows: number): string[];
+    /** Live run progress, otherwise the ranked leaderboard. */
+    benchBottom(innerWidth: number): string[];
+    drawLogs(cols: number): void;
+    header(cols: number): string;
+    modelPanel(innerWidth: number, rows: number): string[];
+    configPanel(innerWidth: number, rows: number): string[];
+    budgetPanel(innerWidth: number): string[];
+    statusPanel(innerWidth: number): string[];
+    /** Full-screen reference so no option ever has to be guessed. */
+    drawHelp(cols: number): void;
+    /**
+     * The key hints for the current mode, as an array of lines. Groups are
+     * deliberately broken onto separate lines — navigation first, then the
+     * actions — and each group wraps further only if the terminal is too narrow.
+     */
+    keybindings(cols: number): string[];
+}
+export {};
+//# sourceMappingURL=app.d.ts.map