@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/finetune/tui.js

@@ -0,0 +1,316 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, render, Text, useInput, useWindowSize } from 'ink';
+import { spawn } from 'node:child_process';
+import React, { useEffect, useState } from 'react';
+import { resolveTheme } from "../host.js";
+import { since } from "./report.js";
+import { short } from "./usage.js";
+const BAR = 20;
+const fit = (text, width) => text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text.padEnd(width);
+const clock = (iso) => {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? '        ' : d.toTimeString().slice(0, 8);
+};
+const seconds = (ms) => ms === undefined
+    ? ''
+    : ms < 60_000
+        ? `${(ms / 1000).toFixed(ms < 10_000 ? 1 : 0)}s`
+        : since(ms);
+function footer(width, keys, theme) {
+    return [
+        [{ text: '─'.repeat(Math.max(0, width)), color: theme.chrome.color }],
+        [{ text: keys, color: theme.chrome.color }],
+    ];
+}
+function keysFor(s, following, url) {
+    if (s.state === 'stopping') {
+        return 'stopping: the steps under way finish first · ctrl-c again kills them';
+    }
+    if (s.state !== 'running') {
+        return s.state;
+    }
+    const open = url ? 'o open in browser · ' : '';
+    return following
+        ? `esc back · ${open}s stop · ctrl-c stop, twice kills`
+        : `up/down choose · enter follow · ${open}s stop · ctrl-c stop, twice kills`;
+}
+/** The platform opener, without a shell, so the address stays one argument. */
+function openInBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'explorer'
+            : 'xdg-open';
+    spawn(command, [url], { stdio: 'ignore', detached: true })
+        .on('error', () => { })
+        .unref();
+}
+function header(s, theme) {
+    const c = s.counts;
+    const n = (k) => c[k] ?? 0;
+    const done = n('completed') + n('difficult');
+    const filled = s.total ? Math.round((done / s.total) * BAR) : 0;
+    const quiet = theme.chrome.color;
+    const tally = [
+        { text: '█'.repeat(filled), color: theme.accent },
+        { text: '░'.repeat(BAR - filled), color: quiet },
+        { text: ` ${done} of ${s.total} done` },
+    ];
+    const add = (text, color) => {
+        tally.push({ text: ` · ${text}`, color });
+    };
+    if (n('completed')) {
+        add(`${n('completed')} completed`);
+    }
+    if (n('difficult')) {
+        add(`${n('difficult')} difficult`, theme.warn);
+    }
+    if (n('failed')) {
+        add(`${n('failed')} failed`, theme.line.error.color);
+    }
+    if (s.parked) {
+        add(`${s.parked} parked, apply at ${s.applyAt}`);
+    }
+    return [
+        [
+            { text: `Fine-tuning ${s.project}`, bold: true },
+            {
+                text: ` · ${s.state} · ${since(s.elapsedMs)} · system v${s.system} · ${s.workers.busy} of ${s.workers.all} workers busy`,
+                color: quiet,
+            },
+        ],
+        tally,
+    ];
+}
+const STAGE_HUE = {
+    dark: { run: 'green', analyze: 'magentaBright', apply: 'blueBright' },
+    light: { run: 'green', analyze: 'magenta', apply: 'blue' },
+};
+/** One hue per stage in every section: run/ran, analyze/analyzed, apply/applied. */
+function hue(word, theme) {
+    const stage = /^(run|ran)\b/.test(word)
+        ? 'run'
+        : word.startsWith('analy')
+            ? 'analyze'
+            : word.startsWith('appl')
+                ? 'apply'
+                : undefined;
+    return stage && STAGE_HUE[theme.appearance][stage];
+}
+/** worker, task, action, elapsed, tokens, model, latest - split around the action cell. */
+function nowCells(cells, width) {
+    const [who = '', what = '', step = '', elapsed = '', tokens = '', model = '', last = ''] = cells;
+    return [
+        `${fit(who, 9)} ${fit(what, 26)} `,
+        fit(step, 8),
+        ` ${fit(elapsed, 7)} ${fit(tokens, 6)} ${fit(model, width >= 110 ? 22 : 16)} ${last}`,
+    ];
+}
+const nowRow = (r) => [
+    r.who,
+    r.what,
+    r.step,
+    since(r.sinceMs),
+    r.act?.calls ? short(r.act.input + r.act.output) : '',
+    r.act?.model ?? '',
+    r.act?.last ?? '',
+];
+/** case, result, took, tokens after the action: the result takes what the others leave. */
+const logCells = (cells, width) => {
+    const [where, result, took, tokens] = cells;
+    return `${fit(where, 31)} ${fit(result, Math.max(10, width - 75))} ${fit(took, 7)} ${tokens}`;
+};
+/** The overview: under way, tokens, log - as many log rows as the height leaves. */
+export function mainLines(s, selected, width, height, theme, url) {
+    const quiet = theme.chrome.color;
+    const out = [...header(s, theme)];
+    if (s.now.length > 0) {
+        out.push([], [{ text: 'In progress', bold: true }]);
+        out.push([
+            {
+                text: `  ${nowCells(['worker', 'task', 'action', 'elapsed', 'tokens', 'model', 'latest'], width).join('')}`,
+                color: quiet,
+            },
+        ]);
+        s.now.forEach((r, i) => {
+            const [before, step, after] = nowCells(nowRow(r), width);
+            out.push([
+                i === selected ? { text: '> ', color: theme.accent, bold: true } : { text: '  ' },
+                { text: before },
+                { text: step, color: hue(r.step, theme) },
+                { text: after },
+            ]);
+        });
+    }
+    if (s.tokens.length > 0) {
+        out.push([], [{ text: 'Tokens so far', bold: true }]);
+        out.push([
+            {
+                text: `${fit('stage', 8)} ${fit('model', 26)} ${'calls'.padStart(6)} ${'in'.padStart(7)} ${'out'.padStart(7)}`,
+                color: quiet,
+            },
+        ]);
+        for (const r of s.tokens) {
+            out.push([
+                { text: fit(r.stage, 8), color: hue(r.stage, theme) },
+                {
+                    text: ` ${fit(r.model, 26)} ${String(r.calls).padStart(6)} ${short(r.input).padStart(7)} ${short(r.output).padStart(7)}`,
+                },
+            ]);
+        }
+    }
+    if (s.errors.length > 0) {
+        const red = theme.line.error.color;
+        out.push([], [{ text: 'Errors', bold: true, color: red }]);
+        for (const e of s.errors) {
+            out.push([
+                { text: `${clock(e.at)} `, color: quiet },
+                { text: `${fit(e.where, 28)} ` },
+                { text: e.message, color: red },
+            ]);
+            if (e.log) {
+                out.push([{ text: `${' '.repeat(9)}log ${e.log}`, color: quiet }]);
+            }
+        }
+    }
+    const room = height - out.length - 2 - 3;
+    if (s.log.length > 0 && room > 0) {
+        out.push([], [{ text: 'Log', bold: true }]);
+        out.push([
+            {
+                text: `${fit('time', 8)} ${fit('action', 18)} ${logCells(['case', 'result', 'took', 'tokens'], width)}`,
+                color: quiet,
+            },
+        ]);
+        for (const r of s.log.slice(0, room)) {
+            out.push([
+                { text: `${clock(r.at)} `, color: quiet },
+                { text: fit(r.action, 18), color: hue(r.action, theme) },
+                {
+                    text: ` ${logCells([r.case, r.result, seconds(r.took), r.tokens ? short(r.tokens) : ''], width)}`,
+                },
+            ]);
+        }
+    }
+    return [...out, ...footer(width, keysFor(s, false, url), theme)];
+}
+function activity(e, theme) {
+    const at = { text: `${clock(e.t)}  `, color: theme.chrome.color };
+    switch (e.type) {
+        case 'llm':
+            return [
+                at,
+                {
+                    text: `model  ${e.model}  ${short(e.in)} in, ${short(e.out)} out${e.ms ? `, ${seconds(e.ms)}` : ''}`,
+                    color: theme.chrome.color,
+                },
+            ];
+        case 'tool':
+            return e.phase === 'start'
+                ? [at, { text: `tool   ${e.name}  `, color: theme.accent }, { text: e.subject }]
+                : [
+                    at,
+                    {
+                        text: `       ${e.ok ? 'done' : 'failed'} ${e.name}${e.ms ? ` ${seconds(e.ms)}` : ''}`,
+                        color: e.ok ? theme.chrome.color : theme.line.error.color,
+                    },
+                ];
+        case 'say':
+            return [at, { text: 'says   ', color: theme.accent }, { text: e.text }];
+        case 'think':
+            return [
+                at,
+                { text: 'thinks ', color: theme.accent },
+                { text: e.text, color: theme.chrome.color },
+            ];
+    }
+}
+/** One step's agent, line by line as it works. */
+export function followLines(s, key, width, height, theme, url) {
+    const r = s.now.find((x) => x.key === key);
+    const out = [];
+    if (!r) {
+        out.push([{ text: 'Nothing is under way there now.', bold: true }]);
+    }
+    else {
+        out.push([
+            { text: `Following ${r.who}`, bold: true },
+            {
+                text: ` · ${r.what} · ${r.step} · ${since(r.sinceMs)}${r.act?.model ? ` · ${r.act.model}` : ''}${r.act?.calls ? ` · ${short(r.act.input + r.act.output)} tokens in ${r.act.calls} calls` : ''}`,
+                color: theme.chrome.color,
+            },
+        ]);
+        out.push([]);
+        const lines = r.act?.lines ?? [];
+        if (lines.length === 0) {
+            out.push([{ text: 'nothing yet', color: theme.chrome.color }]);
+        }
+        for (const e of lines.slice(-Math.max(1, height - out.length - 3))) {
+            out.push(activity(e, theme));
+        }
+    }
+    return [...out, ...footer(width, keysFor(s, true, url), theme)];
+}
+function Live({ t, theme, interrupt, url, }) {
+    const [snap, setSnap] = useState();
+    const [selected, setSelected] = useState(0);
+    const [follow, setFollow] = useState();
+    const { columns, rows } = useWindowSize();
+    useEffect(() => {
+        t.watchers.add(setSnap);
+        return () => {
+            t.watchers.delete(setSnap);
+        };
+    }, [t]);
+    const count = snap?.now.length ?? 0;
+    const at = Math.min(selected, Math.max(0, count - 1));
+    useInput((input, key) => {
+        if ((key.ctrl && input === 'c') || input === 's') {
+            interrupt();
+            return;
+        }
+        if (input === 'o') {
+            if (url) {
+                openInBrowser(url);
+            }
+            return;
+        }
+        if (follow) {
+            if (key.escape) {
+                setFollow(undefined);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setSelected(Math.max(0, at - 1));
+        }
+        else if (key.downArrow) {
+            setSelected(Math.min(count - 1, at + 1));
+        }
+        else if (key.return && snap?.now[at]) {
+            setFollow(snap.now[at].key);
+        }
+    });
+    if (!snap) {
+        return _jsx(Text, { color: theme.chrome.color, children: "starting" });
+    }
+    const height = Math.max(8, rows - 1);
+    const all = follow
+        ? followLines(snap, follow, columns, height, theme, url)
+        : mainLines(snap, at, columns, height, theme, url);
+    // Too short a terminal loses rows from the middle, never the keys at the bottom.
+    const lines = all.length > height ? [...all.slice(0, height - 2), ...all.slice(-2)] : all;
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((parts, i) => (_jsx(Text, { wrap: "truncate-end", children: parts.length === 0
+                ? ' '
+                : parts.map((p, j) => (_jsx(Text, { color: p.color, bold: p.bold, children: p.text }, j))) }, i))) }));
+}
+/** Draws the tuning until the returned function is called. */
+export async function watch(t, interrupt, url) {
+    const theme = await resolveTheme();
+    const instance = render(_jsx(Live, { t: t, theme: theme, interrupt: interrupt, url: url }), {
+        stdout: process.stderr,
+        exitOnCtrlC: false,
+    });
+    return () => instance.unmount();
+}
+//# sourceMappingURL=tui.js.map

package/dist/meta/finetune/tuning.d.ts

@@ -0,0 +1,193 @@
+import { type ChildProcess } from 'node:child_process';
+import type { Case } from './dataset/types.ts';
+import type { Phase } from './feedback.ts';
+import { Improvements } from './improvements.ts';
+import { Journal } from './journal.ts';
+import type { Snapshot } from './live.ts';
+import { Memories } from './memories.ts';
+import { Rechecks } from './recheck.ts';
+import { SystemVersions } from './system.ts';
+import type { ByStage } from './usage.ts';
+export declare const FINETUNE_DIR = "finetune";
+/** Where a tuning was kept before it moved to {@link FINETUNE_DIR}. */
+export declare const LEGACY_FINETUNE_DIR = ".finetune";
+export interface Config {
+    workers: number;
+    /** apply once this many requests are waiting */
+    applyAt: number;
+    tries: number;
+    memTries: number;
+    /** merge the submitted memories after this many more arrive */
+    mergeEvery: number;
+    seed: number;
+    /** completed cases run again after each apply, to catch what it broke */
+    recheck: number;
+    /** bytes one apply may add to what the agents always read */
+    budget: number;
+    /** percent over the start past which an apply may add nothing */
+    maxGrowth: number;
+    /** bytes one on-demand skill may hold */
+    skillCap: number;
+    /** skills one agent may see */
+    maxSkills: number;
+    classes?: string[];
+    ids?: string[];
+    rubric?: boolean;
+    limit?: number;
+}
+export declare const DEFAULTS: Config;
+export type Step = 'idle' | 'run' | 'analyze' | 'parked';
+export interface Worker {
+    slot: number;
+    case?: Case;
+    phase?: Phase;
+    attempt?: number;
+    step: Step;
+    since: number;
+    /** a recheck: the apply whose version it runs on, and the try's folder */
+    recheck?: {
+        apply: string;
+        dir: string;
+    };
+}
+/** A case in flight. It holds a worker only while it runs or is analyzed; parked, it holds none. */
+export interface Seat {
+    case: Case;
+    worker?: Worker;
+    phase?: Phase;
+}
+/** Runs `zen <args>` in the project, stderr into `log`; stdout is returned. */
+export type Zen = (args: string[], log: string) => Promise<{
+    code: number;
+    stdout: string;
+}>;
+export declare class Stopped extends Error {
+    constructor();
+}
+export interface Event {
+    at: string;
+    what: string;
+    worker?: number;
+    case?: string;
+    rev?: number;
+    phase?: Phase;
+    attempt?: number;
+    detail?: string;
+    /** a step that ended: what it came to, how long it took, what it spent */
+    result?: string;
+    took?: number;
+    tokens?: number;
+}
+/** Failed cases in a row, with nothing going through between, that stop the loop. */
+export declare const FAILURES_IN_A_ROW = 3;
+export interface StepFailure {
+    at: string;
+    /** `merge-20 · no memory try 1`, `apply 004`, `memory m03` */
+    where: string;
+    message: string;
+    log?: string;
+}
+export declare class Tuning {
+    readonly root: string;
+    readonly dir: string;
+    readonly config: Config;
+    readonly zen: Zen;
+    readonly tickMs: number;
+    readonly workers: Worker[];
+    readonly claimed: Set<string>;
+    readonly startedAt: number;
+    readonly recent: Event[];
+    readonly system: SystemVersions;
+    readonly journal: Journal;
+    readonly improvements: Improvements;
+    readonly rechecks: Rechecks;
+    readonly memories: Memories;
+    stopping: boolean;
+    finished: boolean;
+    fatal: Error | undefined;
+    /** woken cases waiting for a worker: they go before any new case */
+    resuming: number;
+    /** every case of the selection has been started */
+    drained: boolean;
+    /** cases started by this process: a failed one is not taken twice in one start */
+    readonly tried: Set<string>;
+    /** `--more`: cases of any kind this start may take; not kept in loop.json */
+    more: number | undefined;
+    /** cases failed since the last step that went through */
+    failures: number;
+    /** what the last status page counted */
+    progress: {
+        counts: Record<string, number>;
+        total: number;
+        spent: ByStage;
+    } | undefined;
+    /** called with every live snapshot */
+    readonly watchers: Set<(s: Snapshot) => void>;
+    /** the latest live snapshot */
+    live: Snapshot | undefined;
+    /** the latest step failures, newest first */
+    readonly errors: StepFailure[];
+    constructor(root: string, config: Config, zen: Zen, tickMs?: number);
+    get stopFile(): string;
+    tick(): Promise<void>;
+    stop(why: string): void;
+    /** Between steps: a stop takes effect here, never in the middle of one. */
+    checkStopping(): void;
+    caseDir(c: {
+        id: string;
+        rev: number;
+    }): string;
+    /** Where `retry` puts a case's earlier rounds: `r<rev>.<round>`. */
+    roundsDir(c: {
+        id: string;
+    }): string;
+    /** 1 for a case never retried at this revision. */
+    round(c: {
+        id: string;
+        rev: number;
+    }): number;
+    /** A step went through: the sandbox and the providers are up. */
+    succeeded(): void;
+    /** A case failed for a reason outside the prose. Enough in a row means nothing will go through. */
+    failed(why: string): void;
+    /** No run goes through without the container engine: stop at the first sign, not the third. */
+    sandboxDown(why: string): void;
+    attemptDir(c: {
+        id: string;
+        rev: number;
+    }, phase: Phase, attempt: number): string;
+    /** The folder of the try a worker is on: the case's own, or a recheck's. */
+    workDir(w: Worker & {
+        case: Case;
+    }): string;
+    /** What the loop knows of a try, which a feedback file is never trusted for. */
+    known(c: {
+        id: string;
+        rev: number;
+    }, phase: Phase, attempt: number): {
+        phase: Phase;
+        attempt: number;
+        round?: number | undefined;
+        case: string;
+        caseRev: number;
+    };
+    freeWorker(): Worker | undefined;
+    busy(): number;
+    /** Puts a case on a free worker, waiting for one; a woken case goes before a new one. */
+    seat(s: Seat, woken: boolean): Promise<void>;
+    /** Gives the case's worker back, for another case to use. */
+    unseat(s: Seat): void;
+    /** A case moved to another step on its worker. */
+    at(s: Seat, phase: Phase, attempt: number, step: Step): void;
+    /** A step ended: the worker is between steps until the next `at`, and the event says how it went. */
+    ended(s: Seat, e: Omit<Event, 'at' | 'worker' | 'case' | 'rev'>): void;
+    /** A step failed: kept for the live view, and in events.jsonl with its log. */
+    error(where: string, message: string, log?: string): void;
+    event(e: Omit<Event, 'at'>): void;
+    /** `live`: only what moves by the second is read again; the rest comes from the last full report. */
+    report(live?: boolean): void;
+}
+/** The real `zen`: this same binary, in its own process group so Ctrl-C reaches only us. */
+export declare function spawnZen(root: string, children: Set<ChildProcess>): Zen;
+export declare function readJson<T>(file: string): T | undefined;
+//# sourceMappingURL=tuning.d.ts.map