@zenera/cli 1.1.24 → 1.1.25

package/dist/eventlog.js

@@ -0,0 +1,146 @@
+import { isCheckpoint } from '@zenera/neo';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+const MAX_TEXT = 400;
+const clip = (text) => {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > MAX_TEXT ? `${one.slice(0, MAX_TEXT - 1)}…` : one;
+};
+/** A line that cannot be written is dropped: watching a run must not break it. */
+export function eventLog(path) {
+    mkdirSync(dirname(path), { recursive: true });
+    return (body) => {
+        try {
+            appendFileSync(path, `${JSON.stringify({ t: new Date().toISOString(), ...body })}\n`);
+        }
+        catch {
+            // See above.
+        }
+    };
+}
+/** For `zen run`: the runtime's own events, folded to the shared lines. */
+export function agentEventLog(path) {
+    const write = eventLog(path);
+    // Keyed by branch, since a fork has several model calls open at once.
+    const began = new Map();
+    const said = new Map();
+    return (event) => {
+        const key = event.branch?.name ?? '';
+        if (!isCheckpoint(event)) {
+            if (event.type === 'text_delta') {
+                said.set(key, (said.get(key) ?? '') + event.delta);
+            }
+            return;
+        }
+        switch (event.type) {
+            case 'before_llm_call':
+                began.set(key, Date.now());
+                said.delete(key);
+                break;
+            case 'after_llm_call': {
+                const u = event.node.usage;
+                const at = began.get(key);
+                write({
+                    type: 'llm',
+                    model: event.node.model,
+                    in: u.inputTokens,
+                    cached: u.cachedInputTokens ?? 0,
+                    out: u.outputTokens,
+                    reasoning: u.reasoningTokens ?? 0,
+                    ...(at !== undefined ? { ms: Date.now() - at } : {}),
+                });
+                const text = said.get(key)?.trim();
+                said.delete(key);
+                if (text) {
+                    write({ type: 'say', text: clip(text) });
+                }
+                break;
+            }
+            case 'before_tool_call':
+                write({
+                    type: 'tool',
+                    phase: 'start',
+                    id: event.call.callId,
+                    name: event.call.name,
+                    subject: clip(event.call.args.preview ?? ''),
+                });
+                break;
+            case 'after_tool_call':
+                write({
+                    type: 'tool',
+                    phase: 'end',
+                    id: event.node.callId,
+                    name: event.node.name,
+                    ok: !event.node.isError,
+                    ...(event.node.durationMs !== undefined ? { ms: event.node.durationMs } : {}),
+                });
+                break;
+            default:
+                break;
+        }
+    };
+}
+/**
+ * For `zen meta run`: copilot's events and spans, folded to the same lines.
+ * Its JSONL has no token counts, so `llm` lines come from the spans instead,
+ * about a second after each call.
+ */
+export function copilotEventLog(path) {
+    const write = eventLog(path);
+    // Its completion names no tool, so the start is remembered by call id.
+    const began = new Map();
+    return {
+        event: (event) => {
+            const data = event.data ?? {};
+            const id = String(data.toolCallId ?? '');
+            switch (event.type) {
+                case 'assistant.message': {
+                    const text = String(data.content ?? '').trim();
+                    if (text) {
+                        write({ type: 'say', text: clip(text) });
+                    }
+                    break;
+                }
+                case 'tool.execution_start': {
+                    const args = (data.arguments ?? {});
+                    const subject = args.command ?? args.description ?? args.path ?? args.skill ?? '';
+                    const name = String(data.toolName ?? 'tool');
+                    began.set(id, { at: Date.now(), name });
+                    write({
+                        type: 'tool',
+                        phase: 'start',
+                        id,
+                        name,
+                        subject: clip(typeof subject === 'string' ? subject : JSON.stringify(subject)),
+                    });
+                    break;
+                }
+                case 'tool.execution_complete': {
+                    const start = began.get(id);
+                    began.delete(id);
+                    write({
+                        type: 'tool',
+                        phase: 'end',
+                        id,
+                        name: start?.name ?? String(data.toolName ?? 'tool'),
+                        ok: data.success !== false,
+                        ...(start ? { ms: Date.now() - start.at } : {}),
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        },
+        call: (call) => write({
+            type: 'llm',
+            model: call.model,
+            in: call.usage.inputTokens,
+            cached: call.usage.cachedInputTokens,
+            out: call.usage.outputTokens,
+            reasoning: call.usage.reasoningTokens,
+            ms: call.durationMs,
+        }),
+    };
+}
+//# sourceMappingURL=eventlog.js.map

package/dist/liveness.d.ts

@@ -54,6 +54,13 @@ export interface ModelProbe {
     /** embeddings only: the width the model actually returned */
     dimensions?: number;
 }
+/**
+ * A chat model sized for a probe: 16 output tokens is enough for "ok", and
+ * Anthropic requires a cap at all. Only the adapters that read `maxTokens` are
+ * given one — the registry refuses a knob its adapter would never send, and the
+ * OpenAI adapters have no such knob.
+ */
+export declare function probeChat(provider: string, id: string): Model;
 export declare function probeModel(target: ModelTarget): Promise<ModelProbe>;
 /**
  * One round trip per model, run together — they are independent questions, and

package/dist/liveness.js

@@ -1,4 +1,4 @@
-import { EXA_BASE_URL, isUnfunded, ModelRegistry, text, } from '@zenera/neo';
+import { createModel, EXA_BASE_URL, isUnfunded, ModelRegistry, text, vertexRoute, } from '@zenera/neo';
 import { envOf, SHAPES, } from "./keys.js";
 // ---------------------------------------------------------------------------
 // Liveness
@@ -389,6 +389,17 @@ const UNSERVED = [
     'no access',
 ];
 const targetId = (target) => target.kind === 'model' ? target.model.id : target.embedder.id;
+/**
+ * A chat model sized for a probe: 16 output tokens is enough for "ok", and
+ * Anthropic requires a cap at all. Only the adapters that read `maxTokens` are
+ * given one — the registry refuses a knob its adapter would never send, and the
+ * OpenAI adapters have no such knob.
+ */
+export function probeChat(provider, id) {
+    const capped = { provider, model: id, maxTokens: 16 };
+    const unread = new ModelRegistry().knobs(capped).some((k) => k.knob === 'maxTokens');
+    return createModel(unread ? { provider, model: id } : capped);
+}
 /**
  * Refused by the provider, unreachable, or served.
  *
@@ -413,6 +424,9 @@ function classifyModel(err, target) {
 /** The command that finds something this account can actually use. */
 function instead(target) {
     const provider = target.ref.includes(':') ? target.ref.split(':')[0] : undefined;
+    if (provider === 'vertex' && vertexRoute(targetId(target)) !== 'gemini') {
+        return 'enable it for this project in Model Garden: https://console.cloud.google.com/vertex-ai/model-garden';
+    }
     return provider
         ? `zen models ls ${provider}`
         : `zen models pick --${target.kind === 'embedding' ? 'embedding' : 'chat'}`;

package/dist/meta/editor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Writes the editor's files under `dir`, replacing what is there. They are
+ * ours: they say how the editor is to treat a directory the agents write into,
+ * and they describe the file formats of the version of `zen` in hand, so the
+ * current answer is the only one worth having and a stale one is worse than
+ * none. Returns the relative paths written.
+ */
+export declare function editorFiles(dir: string): string[];
+//# sourceMappingURL=editor.d.ts.map

package/dist/meta/editor.js

@@ -0,0 +1,60 @@
+import { copyFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { copyTree, MEMORY_RULES, TEMPLATES } from "./host.js";
+// ---------------------------------------------------------------------------
+// Telling the editor which instructions are not for it
+//
+// The project's house rules are `agents/instructions.md`, deliberately not
+// `AGENTS.md`: every coding assistant now reads that name out of an open
+// folder and feeds it to itself as always-on instructions, and `zen open`
+// opens exactly this directory. A name nobody else claims means the two are
+// never confused, and `chat.useAgentsMdFile` no longer has to be switched off
+// to keep them apart.
+//
+// They sit under `agents/` because there is rarely only one of them. Anything
+// named `agents/<topic>-instructions.md` is read too, in filename order, so a
+// subject that is true for every agent but is about one capability — memory,
+// say — gets its own document instead of another section in a file that keeps
+// growing.
+//
+// `chat.useNestedAgentsMdFiles` is still written. It is already false by
+// default, but it is opt-in globally, and this is a directory the agent itself
+// writes into — someone who turned it on would otherwise have the editor pick
+// up whatever `AGENTS.md` a run happened to leave behind. It is a *restricted*
+// setting, so it applies only in a trusted workspace; that is the right way
+// round, since an untrusted folder is not one to run agents in either.
+//
+// `agents/instructions.md` addresses the *project's* agents. The editor's
+// assistant still needs a brief of its own, and what it needs to know is how
+// this kind of project is put together — the file formats, how a prompt is
+// written, when to add a skill rather than an agent. That is what the
+// `.github/` tree is: the standing brief, plus the prompt files and skills the
+// editor picks up from the same place.
+// ---------------------------------------------------------------------------
+/** The same bytes, kept in the `zen-memory` skill to restore or diff against. */
+const MEMORY_REFERENCE = join('.github', 'skills', 'zen-memory', 'references', 'memory-instructions.md');
+/**
+ * Writes the editor's files under `dir`, replacing what is there. They are
+ * ours: they say how the editor is to treat a directory the agents write into,
+ * and they describe the file formats of the version of `zen` in hand, so the
+ * current answer is the only one worth having and a stale one is worse than
+ * none. Returns the relative paths written.
+ */
+export function editorFiles(dir) {
+    const written = copyTree(join(TEMPLATES, 'editor'), dir, '', {});
+    // The one file that belongs to both trees. It is a project file first —
+    // house rules reaching every agent that can see the graph — and it is
+    // written once and edited from then on, like every other project file. But
+    // a project whose copy drifted, or that deleted it and turned memory back
+    // on later, needs somewhere to get the current text from, and the editor
+    // tree is replaced on every `init` and `open`. Copying the same bytes into
+    // the skill's references is what makes `diff` between the two mean
+    // something, and what stops a second copy of these rules existing in the
+    // repository to fall out of step with the first.
+    const reference = join(dir, MEMORY_REFERENCE);
+    mkdirSync(dirname(reference), { recursive: true });
+    copyFileSync(join(TEMPLATES, 'project', MEMORY_RULES), reference);
+    written.push(MEMORY_REFERENCE);
+    return written;
+}
+//# sourceMappingURL=editor.js.map

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

@@ -0,0 +1,8 @@
+export declare function remember(tuningDir: string, pid: number, marker: string): void;
+export declare function forget(tuningDir: string, pid: number): void;
+/**
+ * Stops every child a dead loop left running, and waits until they are gone.
+ * Only under the loop's lock: a live loop's children look the same.
+ */
+export declare function reap(tuningDir: string, graceMs?: number): Promise<number[]>;
+//# sourceMappingURL=children.d.ts.map

package/dist/meta/finetune/children.js

@@ -0,0 +1,76 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+const folder = (tuningDir) => join(tuningDir, 'children');
+export function remember(tuningDir, pid, marker) {
+    mkdirSync(folder(tuningDir), { recursive: true });
+    const row = { pid, marker, at: new Date().toISOString() };
+    writeFileSync(join(folder(tuningDir), `${pid}.json`), `${JSON.stringify(row)}\n`);
+}
+export function forget(tuningDir, pid) {
+    rmSync(join(folder(tuningDir), `${pid}.json`), { force: true });
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+};
+const commandOf = (pid) => spawnSync('ps', ['-o', 'command=', '-p', String(pid)], { encoding: 'utf8' }).stdout ?? '';
+const signal = (pid, sig) => {
+    try {
+        process.kill(-pid, sig);
+    }
+    catch {
+        try {
+            process.kill(pid, sig);
+        }
+        catch {
+            // Gone already.
+        }
+    }
+};
+/**
+ * Stops every child a dead loop left running, and waits until they are gone.
+ * Only under the loop's lock: a live loop's children look the same.
+ */
+export async function reap(tuningDir, graceMs = 10_000) {
+    let names = [];
+    try {
+        names = readdirSync(folder(tuningDir)).filter((n) => n.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const left = [];
+    for (const name of names) {
+        let child;
+        try {
+            child = JSON.parse(readFileSync(join(folder(tuningDir), name), 'utf8'));
+        }
+        catch {
+            // A row torn by the kill itself.
+        }
+        if (child && alive(child.pid) && commandOf(child.pid).includes(child.marker)) {
+            signal(child.pid, 'SIGTERM');
+            left.push(child.pid);
+        }
+    }
+    const until = Date.now() + graceMs;
+    while (left.some(alive) && Date.now() < until) {
+        await sleep(100);
+    }
+    for (const pid of left.filter(alive)) {
+        signal(pid, 'SIGKILL');
+    }
+    while (left.some(alive) && Date.now() < until + 2000) {
+        await sleep(50);
+    }
+    rmSync(folder(tuningDir), { recursive: true, force: true });
+    return left;
+}
+//# sourceMappingURL=children.js.map

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

@@ -0,0 +1,30 @@
+import { type Config, type Zen } from './tuning.ts';
+export declare const FINETUNE_USAGE = "zen meta finetune <start|status|stop|retry|session> [options]";
+export declare const FINETUNE_HELP: string[];
+export declare const FINETUNE_SUMMARY = "Tune the project's prose on its dataset, a case at a time, N cases at once.";
+/** The page `zen meta finetune --help` prints. */
+export declare const FINETUNE_DETAILS: string[];
+export interface FinetuneContext {
+    readonly args: readonly string[];
+    readonly json: boolean;
+    readonly cwd: string;
+}
+export declare function finetuneProjectFlag(args: readonly string[]): string | undefined;
+export interface FinetuneOptions {
+    /** stands in for the `zen` binary - tests */
+    zen?: Zen;
+    tickMs?: number;
+}
+export declare function runFinetune(ctx: FinetuneContext, project: {
+    dir: string;
+    name: string;
+}, options?: FinetuneOptions): Promise<void>;
+/**
+ * A tuning used to live in `.finetune/`. Moves it to `finetune/` once, so a
+ * project tuned before the rename resumes where it stopped. Refuses while a
+ * loop of the old version still holds its lock there: renaming its folder out
+ * from under it would split one tuning across two directories.
+ */
+export declare function moveLegacyDir(projectDir: string): void;
+export declare function readConfig(dir: string): Config;
+//# sourceMappingURL=command.d.ts.map