@zenera/cli 1.1.24 → 1.1.25

package/dist/meta/finetune/improvements.js

@@ -0,0 +1,244 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { errorIn, sizeOf } from "./failure.js";
+import { writeApply } from "./report.js";
+import { readJson, Stopped } from "./tuning.js";
+import { envelopesIn, spent } from "./usage.js";
+const pad = (n) => String(n).padStart(3, '0');
+export class Improvements {
+    #t;
+    pending = [];
+    /** the batch an apply is working on */
+    inApply = [];
+    #applied = new Set();
+    /** cases parked right now */
+    parked = 0;
+    /** `zen run`s in flight */
+    runs = 0;
+    applying = false;
+    /** the apply under way; `name` once it has a folder, before that it waits for runs */
+    current;
+    /** applies started in this process */
+    started = 0;
+    /** applies finished in this process - an analysis spanning one may see edits */
+    count = 0;
+    constructor(t) {
+        this.#t = t;
+        this.reload();
+    }
+    /** Re-reads which requests the applies took - a recovery may have removed one. */
+    reload() {
+        this.#applied.clear();
+        for (const name of this.#names()) {
+            for (const id of readJson(join(this.dir, name, 'applied.json'))?.ids ??
+                []) {
+                this.#applied.add(id);
+            }
+        }
+    }
+    get dir() {
+        return join(this.#t.dir, 'applies');
+    }
+    #names() {
+        try {
+            return readdirSync(this.dir)
+                .filter((n) => /^\d{3}$/.test(n))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    isApplied(id) {
+        return this.#applied.has(id);
+    }
+    /** Parks until an apply has taken this feedback, the worker free meanwhile. Taken already - after a restart - returns at once. */
+    async apply(feedback, s) {
+        if (this.#applied.has(feedback.id)) {
+            return;
+        }
+        if (!this.pending.some((f) => f.id === feedback.id)) {
+            this.pending.push(feedback);
+        }
+        this.parked++;
+        this.#t.event({
+            what: 'parked',
+            worker: s.worker?.slot,
+            case: feedback.case,
+            phase: feedback.phase,
+            attempt: feedback.attempt,
+            detail: `${feedback.improvements.length} improvement(s), worker freed`,
+        });
+        this.#t.unseat(s);
+        try {
+            while (!this.#applied.has(feedback.id)) {
+                if (this.#t.stopping) {
+                    throw new Stopped();
+                }
+                await this.#t.tick();
+            }
+        }
+        finally {
+            this.parked--;
+        }
+        await this.#t.seat(s, true);
+    }
+    /** Before a run starts: wait out an apply, or stop. */
+    async notApplying() {
+        while (this.applying) {
+            this.#t.checkStopping();
+            await this.#t.tick();
+        }
+        this.#t.checkStopping();
+    }
+    /** The applier: runs until the tuning is finished. */
+    async loop() {
+        while (!this.#t.finished) {
+            await this.#t.tick();
+            if (this.#t.stopping || this.pending.length === 0) {
+                continue;
+            }
+            if (this.pending.length < this.#t.config.applyAt &&
+                (this.#t.busy() > 0 || !this.#t.drained)) {
+                continue;
+            }
+            try {
+                await this.#applyNow();
+            }
+            catch (err) {
+                this.#t.fatal = err;
+                this.#t.stop(`apply failed: ${err.message}`);
+            }
+        }
+    }
+    async #applyNow() {
+        const t = this.#t;
+        this.applying = true;
+        this.current = { since: Date.now() };
+        this.started++;
+        t.event({ what: 'apply waiting', detail: `${this.runs} run(s) to finish` });
+        try {
+            while (this.runs > 0) {
+                await t.tick();
+            }
+            const batch = this.pending.splice(0);
+            this.inApply = batch;
+            const name = pad(Math.max(0, ...this.#names().map(Number)) + 1);
+            const dir = join(this.dir, name);
+            const from = t.system.record('external').v;
+            await t.journal.step({ kind: 'apply', dir, from }, () => this.#applyBatch(batch, name, dir, from));
+        }
+        finally {
+            this.applying = false;
+            this.current = undefined;
+            this.inApply = [];
+        }
+    }
+    async #applyBatch(batch, name, dir, from) {
+        const t = this.#t;
+        const startedAt = new Date().toISOString();
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'inputs.json'), `${JSON.stringify(batch.map((f) => ({
+            ...f,
+            file: join(t.attemptDir({ id: f.case, rev: f.caseRev }, f.phase, f.attempt), 'feedback.json'),
+        })), null, 2)}\n`);
+        const total = batch.reduce((n, f) => n + f.improvements.length, 0);
+        this.current = { since: Date.now(), name, dir, requests: batch.length };
+        let to = from;
+        if (total > 0) {
+            t.event({
+                what: 'apply',
+                detail: `${name}: ${batch.length} request(s), ${total} improvement(s)`,
+            });
+            writeApply(t, dir);
+            try {
+                await this.#edit(dir, from);
+            }
+            catch (err) {
+                writeFileSync(join(dir, 'failed.json'), `${JSON.stringify({ at: new Date().toISOString(), startedAt, error: err.message }, null, 2)}\n`);
+                writeApply(t, dir);
+                throw err;
+            }
+            to = t.system.record('apply', name).v;
+            if (to !== from) {
+                writeFileSync(join(dir, 'diff.patch'), t.system.diff(from, to));
+            }
+        }
+        const applied = {
+            ids: batch.map((f) => f.id),
+            from,
+            to,
+            at: new Date().toISOString(),
+            startedAt,
+            ...(total === 0 ? { skipped: true } : {}),
+        };
+        writeFileSync(join(dir, 'applied.json'), `${JSON.stringify(applied, null, 2)}\n`);
+        writeApply(t, dir);
+        for (const f of batch) {
+            this.#applied.add(f.id);
+        }
+        this.count++;
+        this.current = undefined;
+        t.event({
+            what: 'applied',
+            detail: `${name}: v${from} -> v${to}, see applies/${name}/APPLY.md`,
+            result: total === 0 ? 'nothing to change' : `v${from} → v${to}`,
+            took: Date.now() - Date.parse(startedAt),
+            tokens: spent(envelopesIn(dir, 'apply')),
+        });
+    }
+    /** The meta agent edits; `zen check` must pass, or the edit is undone and tried once more. */
+    async #edit(dir, from) {
+        const t = this.#t;
+        for (let attempt = 1;; attempt++) {
+            const session = randomUUID();
+            writeFileSync(join(dir, 'session'), `${session}\n`);
+            const applyLog = join(dir, 'apply.log');
+            const checkLog = join(dir, 'check.log');
+            const offset = { apply: sizeOf(applyLog), check: sizeOf(checkLog) };
+            const res = await t.zen([
+                'meta',
+                'run',
+                '--no-refresh',
+                '--json',
+                '--session-id',
+                session,
+                '--events',
+                join(dir, 'apply.events.jsonl'),
+                '/finetune-apply',
+                dir,
+            ], applyLog);
+            writeFileSync(join(dir, attempt === 1 ? 'apply.json' : `apply-${attempt}.json`), res.stdout);
+            const check = await t.zen(['check', '--no-models', '--no-sandbox'], checkLog);
+            if (res.code === 0 && check.code === 0) {
+                return;
+            }
+            const e = res.code !== 0 ? errorIn(applyLog, offset.apply) : errorIn(checkLog, offset.check);
+            t.error(`apply ${basename(dir)}${attempt > 1 ? ` try ${attempt}` : ''}`, `${res.code !== 0 ? 'the apply failed' : 'zen check failed after the apply'}${e.message ? `: ${e.message}` : ''}`, e.log);
+            t.system.restore(from);
+            if (attempt === 2) {
+                throw new Error(`apply ${dir} left the project broken twice - see check.log`);
+            }
+            t.event({
+                what: 'apply retry',
+                detail: res.code !== 0 ? 'the apply failed' : 'zen check failed',
+            });
+        }
+    }
+    /** Requests every apply so far took, for the report. */
+    applies() {
+        return this.#names().map((name) => {
+            const dir = join(this.dir, name);
+            return {
+                name,
+                dir,
+                applied: readJson(join(dir, 'applied.json')),
+                inputs: existsSync(join(dir, 'inputs.json'))
+                    ? readJson(join(dir, 'inputs.json'))
+                    : undefined,
+            };
+        });
+    }
+}
+//# sourceMappingURL=improvements.js.map

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

@@ -0,0 +1,2 @@
+export { FINETUNE_DETAILS, FINETUNE_HELP, FINETUNE_SUMMARY, FINETUNE_USAGE, finetuneProjectFlag, runFinetune, } from './command.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/meta/finetune/index.js

@@ -0,0 +1,2 @@
+export { FINETUNE_DETAILS, FINETUNE_HELP, FINETUNE_SUMMARY, FINETUNE_USAGE, finetuneProjectFlag, runFinetune, } from "./command.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,35 @@
+import type { Tuning } from './tuning.ts';
+export type Tx = {
+    kind: 'run';
+    dir: string;
+} | {
+    kind: 'analyze';
+    dir: string;
+} | {
+    kind: 'apply';
+    dir: string;
+    from: number;
+} | {
+    kind: 'merge';
+    dir: string;
+    log: string;
+};
+export declare class Journal {
+    #private;
+    readonly file: string;
+    constructor(file: string);
+    begin(tx: Tx): string;
+    end(id: string, op: 'commit' | 'failed' | 'rollback'): void;
+    /** Runs `fn` as one transaction. */
+    step<T>(tx: Tx, fn: () => Promise<T>): Promise<T>;
+    /** Transactions begun and never closed, oldest first. */
+    open(): {
+        id: string;
+        tx: Tx;
+    }[];
+    /** Every transaction closed: the history can go. */
+    clear(): void;
+}
+/** Rolls back what a kill cut off. Only under the loop's lock: a live step looks the same. */
+export declare function recover(t: Tuning): Promise<void>;
+//# sourceMappingURL=journal.d.ts.map

package/dist/meta/finetune/journal.js

@@ -0,0 +1,135 @@
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative } from 'node:path';
+import { reap } from "./children.js";
+/** What a step leaves in its attempt folder; the logs stay, they only grow. */
+const OUTPUTS = {
+    run: ['run.json', 'envelope.json', 'request.json', 'events.jsonl', 'memory', 'workspace'],
+    analyze: [
+        'feedback.json',
+        'analysis.md',
+        'analyze.json',
+        'analyze-2.json',
+        'analyze.events.jsonl',
+    ],
+};
+export class Journal {
+    file;
+    #base;
+    constructor(file) {
+        this.file = file;
+        this.#base = dirname(file);
+    }
+    #append(row) {
+        mkdirSync(this.#base, { recursive: true });
+        appendFileSync(this.file, `${JSON.stringify(row)}\n`);
+    }
+    // Paths are kept relative, so a project moved between sessions still recovers.
+    #paths(tx, to) {
+        return { ...tx, dir: to(tx.dir), ...('log' in tx ? { log: to(tx.log) } : {}) };
+    }
+    begin(tx) {
+        const id = randomUUID().slice(0, 8);
+        this.#append({
+            id,
+            at: new Date().toISOString(),
+            op: 'begin',
+            tx: this.#paths(tx, (p) => relative(this.#base, p)),
+        });
+        return id;
+    }
+    end(id, op) {
+        this.#append({ id, at: new Date().toISOString(), op });
+    }
+    /** Runs `fn` as one transaction. */
+    async step(tx, fn) {
+        const id = this.begin(tx);
+        let result;
+        try {
+            result = await fn();
+        }
+        catch (err) {
+            this.end(id, 'failed');
+            throw err;
+        }
+        this.end(id, 'commit');
+        return result;
+    }
+    /** Transactions begun and never closed, oldest first. */
+    open() {
+        let text = '';
+        try {
+            text = readFileSync(this.file, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        const begun = new Map();
+        for (const line of text.split('\n')) {
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                // A line torn by the kill itself.
+                continue;
+            }
+            if (row.op === 'begin') {
+                begun.set(row.id, row.tx);
+            }
+            else {
+                begun.delete(row.id);
+            }
+        }
+        return [...begun].map(([id, tx]) => ({
+            id,
+            tx: this.#paths(tx, (p) => (isAbsolute(p) ? p : join(this.#base, p))),
+        }));
+    }
+    /** Every transaction closed: the history can go. */
+    clear() {
+        rmSync(this.file, { force: true });
+    }
+}
+/** Rolls back what a kill cut off. Only under the loop's lock: a live step looks the same. */
+export async function recover(t) {
+    // Before anything is rolled back: a child still running would write into it again.
+    const reaped = await reap(t.dir);
+    if (reaped.length > 0) {
+        t.event({
+            what: 'stopped leftovers',
+            detail: `${reaped.length} process(es) the last loop left running`,
+        });
+    }
+    const open = t.journal.open().reverse();
+    for (const { id, tx } of open) {
+        rollback(t, tx);
+        t.journal.end(id, 'rollback');
+        t.event({ what: 'rolled back', detail: `${tx.kind} ${relative(t.dir, tx.dir)}` });
+    }
+    if (open.some(({ tx }) => tx.kind === 'apply')) {
+        t.improvements.reload();
+    }
+    t.journal.clear();
+}
+function rollback(t, tx) {
+    switch (tx.kind) {
+        case 'run':
+        case 'analyze':
+            for (const name of OUTPUTS[tx.kind]) {
+                rmSync(join(tx.dir, name), { recursive: true, force: true });
+            }
+            return;
+        case 'apply':
+            // Its edits never passed `zen check`: put back the version it started from.
+            t.system.restore(tx.from);
+            t.system.drop(basename(tx.dir));
+            rmSync(tx.dir, { recursive: true, force: true });
+            return;
+        case 'merge':
+            rmSync(tx.dir, { recursive: true, force: true });
+            rmSync(tx.log, { force: true });
+            return;
+    }
+}
+//# sourceMappingURL=journal.js.map

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

@@ -0,0 +1,74 @@
+import type { EventLine } from '../host.ts';
+import type { StepFailure, Tuning } from './tuning.ts';
+import { type Stage } from './usage.ts';
+export interface ModelSpend {
+    calls: number;
+    input: number;
+    output: number;
+}
+/** One events file, folded as it grows. */
+export interface Activity {
+    model?: string;
+    calls: number;
+    input: number;
+    output: number;
+    byModel: Record<string, ModelSpend>;
+    /** the latest tool call or thing said */
+    last?: string;
+    /** the latest lines, oldest first */
+    lines: EventLine[];
+}
+export interface NowRow {
+    /** stable across snapshots: `w1`, `apply`, `merge` */
+    key: string;
+    who: string;
+    step: string;
+    what: string;
+    sinceMs: number;
+    stage?: Stage;
+    act?: Activity;
+}
+export interface TokenRow extends ModelSpend {
+    stage: Stage;
+    model: string;
+}
+export interface LogRow {
+    at: string;
+    action: string;
+    case: string;
+    result: string;
+    took?: number;
+    tokens?: number;
+}
+export interface Snapshot {
+    pid: number;
+    project: string;
+    state: 'running' | 'stopping' | 'stopped' | 'finished';
+    at: string;
+    elapsedMs: number;
+    system: number;
+    workers: {
+        busy: number;
+        all: number;
+    };
+    total: number;
+    counts: Record<string, number>;
+    parked: number;
+    applyAt: number;
+    now: NowRow[];
+    tokens: TokenRow[];
+    log: LogRow[];
+    /** the latest step failures, newest first */
+    errors: StepFailure[];
+}
+/** Reads only what each events file gained since the last look; a file cleared for a new step starts over. */
+export declare class Tails {
+    #private;
+    read(file: string): Activity;
+    /** Forgets the files no step writes any more. */
+    keep(files: ReadonlySet<string>): void;
+}
+export declare function snapshot(t: Tuning): Snapshot;
+/** Takes a snapshot, keeps it in live.json without the raw lines, and hands it to every watcher. */
+export declare function publish(t: Tuning): Snapshot | undefined;
+//# sourceMappingURL=live.d.ts.map