@zenera/cli 1.1.27 → 1.1.29

package/dist/meta/finetune/guard.js

@@ -1,104 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { readFeedback } from "./feedback.js";
-import { resultOf, selection } from "./sampler.js";
-import { keepAnalysis, runOnce } from "./train.js";
-import { readJson } from "./tuning.js";
-/** A case is broken only after failing this many tries in a row. */
-export const GUARD_TRIES = 2;
-const pad = (n) => String(n).padStart(2, '0');
-/** Completed cases outside `exclude`, in an order fixed by the seed and the apply. */
-export function guardCases(t, apply, exclude) {
-    const key = (id) => createHash('sha256').update(`${t.config.seed}:${apply}:${id}`).digest('hex');
-    return selection(t)
-        .filter((c) => !exclude.has(c.id) && resultOf(t, c)?.state === 'completed')
-        .sort((a, b) => key(a.id).localeCompare(key(b.id)))
-        .slice(0, t.config.guard);
-}
-/** Runs the guard for one attempt of an apply; `patch` is that attempt's diff. */
-export async function guard(t, dir, attempt, exclude, patch) {
-    const cases = guardCases(t, basename(dir), exclude);
-    if (cases.length === 0) {
-        return [];
-    }
-    const seats = cases.map((c) => ({
-        case: c.id,
-        try: 1,
-        step: 'run',
-        dir: join(dir, 'guard', `a${attempt}`, c.id),
-        since: Date.now(),
-    }));
-    if (t.improvements.current) {
-        t.improvements.current.guard = seats;
-    }
-    t.event({
-        what: 'guard',
-        detail: `${basename(dir)}: ${cases.map((c) => c.id).join(', ')} run again on the edit`,
-    });
-    const results = await Promise.all(cases.map((c, i) => guardOne(t, join(dir, 'guard', `a${attempt}`, c.id), c, patch, seats[i])));
-    writeFileSync(join(dir, 'guard.json'), `${JSON.stringify(results, null, 2)}\n`);
-    return results;
-}
-async function guardOne(t, dir, c, patch, seat) {
-    const tries = [];
-    for (let n = 1; n <= GUARD_TRIES; n++) {
-        const at = join(dir, `${pad(n)}-nomem`);
-        const one = await tryOne(t, c, at, n, patch, seat);
-        tries.push(one);
-        if (one.passed) {
-            break;
-        }
-    }
-    const broken = tries.length === GUARD_TRIES && tries.every((x) => !x.passed);
-    Object.assign(seat, { step: broken ? 'broken' : 'passed', since: Date.now() });
-    t.event({
-        what: broken ? 'guard broken' : 'guard passed',
-        case: c.id,
-        rev: c.rev,
-        detail: tries.map((x) => x.verdict).join(', '),
-    });
-    return { case: c.id, tries, broken };
-}
-/** A run or an analysis that says nothing about the prose counts as a pass: only a graded failure undoes an apply. */
-async function tryOne(t, c, dir, n, patch, seat) {
-    mkdirSync(dir, { recursive: true });
-    Object.assign(seat, { try: n, step: 'run', dir, since: Date.now() });
-    const why = await runOnce(t, c, dir);
-    if (why) {
-        return { dir, verdict: 'void', passed: true, summary: why };
-    }
-    const run = readJson(join(dir, 'run.json'));
-    const file = join(dir, 'feedback.json');
-    Object.assign(seat, { step: 'analyze', since: Date.now() });
-    const res = await t.zen([
-        'meta',
-        'run',
-        '--no-refresh',
-        '--json',
-        '--events',
-        join(dir, 'analyze.events.jsonl'),
-        '--session-id',
-        randomUUID(),
-        '/analyze',
-        run.dir,
-        `case=${c.id}`,
-        `rev=${c.rev}`,
-        'phase=nomem',
-        `attempt=${n}`,
-        `feedback=${file}`,
-        `guard=${patch}`,
-    ], join(dir, 'analyze.log'));
-    keepAnalysis(dir, res.stdout);
-    const read = readFeedback(file, { case: c.id, caseRev: c.rev, phase: 'nomem', attempt: n }, c.rubric.map((r) => r.id));
-    if (!('feedback' in read)) {
-        return { dir, verdict: 'unread', passed: true, summary: read.problem };
-    }
-    const f = read.feedback;
-    if (f.verdict === 'void') {
-        return { dir, verdict: 'void', passed: true, summary: f.infra };
-    }
-    const passed = f.verdict === 'right' && !Object.values(f.rubric).includes('fail');
-    return { dir, verdict: f.verdict, passed, summary: f.summary };
-}
-//# sourceMappingURL=guard.js.map

package/dist/meta.d.ts

@@ -1,291 +0,0 @@
-import type { ModelUsage, TokenUsage } from '@zenera/neo';
-import { spawn as nodeSpawn } from 'node:child_process';
-import { type KeyEntry, type KeyStore, type Provider } from './keys.ts';
-export declare const PROMPT_DIR = ".github/prompts";
-/** The variable a project's `.env` names it with — a zen ref, not a wire id. */
-export declare const MODEL_ENV = "ZENERA_META_MODEL";
-export type ModelSource = 'flag' | 'shell' | 'env' | 'store' | 'project' | 'default';
-export interface ModelChoice {
-    /** a zen ref: `vertex/gemini-3.8-flash`, or a bare id for the default provider */
-    ref: string;
-    from: ModelSource;
-}
-export interface ModelSources {
-    flag?: string;
-    /** `ZENERA_META_MODEL` as it stood before the project's `.env` was folded in */
-    shell?: string;
-    /** the same variable after it was, which is the `.env` answer when they differ */
-    env?: string;
-    stored?: string;
-    /** the project's `agents.yaml` `model:` */
-    project?: string;
-    /** what a held key recommends, when nothing above answered */
-    fallback?: string;
-}
-/** Where the answer is looked for, best first. */
-export declare const ORDER: readonly ModelSource[];
-export declare function chooseModel(sources: ModelSources): ModelChoice | undefined;
-export declare const SOURCE_LABELS: Record<ModelSource, string>;
-/** First of each row is the default; the rest are what `--pick` offers beside it. */
-export declare const RECOMMENDED: Partial<Record<Provider, readonly string[]>>;
-/** The recommended ref for the first provider with a key, or for `only`. */
-export declare function defaultRef(store: KeyStore, only?: Provider): string | undefined;
-export interface MetaFile {
-    version: 1;
-    model?: string;
-}
-export declare const readMeta: () => Promise<MetaFile>;
-export declare function writeMeta(file: MetaFile): void;
-/**
- * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider
- * counts as a prefix, because `google/gemini-3.8-flash` is also a perfectly good
- * bare id on an endpoint that speaks publisher names.
- *
- * The colon form is the library's own — `openai:gpt-5.6-sol`, and with an api
- * selector `openai/responses:gpt-5.6-sol` — which is what arrives when the ref
- * came from `agents.yaml`.
- */
-export declare function splitRef(ref: string): {
-    provider?: Provider;
-    id: string;
-};
-/**
- * The provider a misspelt prefix was reaching for, if that is what it is.
- *
- * `vertes/gemini-3.8-flash` is shaped exactly like the OpenRouter id
- * `meta-llama/llama-4`, so an unknown prefix cannot be an error on its own —
- * only one close enough to a real provider name to be a slip of the hand.
- */
-export declare function misspelledProvider(ref: string): Provider | undefined;
-/**
- * Copilot offers its tools as OpenAI *custom* tools, which the completions API
- * rejects outright — `400 Invalid value: 'custom'`. Only the responses API
- * takes them, and only the reasoning models serve it, so the wire API follows
- * the model rather than being a flag nobody would know to set. Older models are
- * listed rather than newer ones, so each new generation works without a release.
- */
-export declare function wireApi(provider: Provider, id: string): string | undefined;
-export interface Wiring {
-    provider: Provider;
-    /** what the model is called on the wire */
-    model: string;
-    /** every `COPILOT_*` name and value, ready to hand to the child */
-    env: Record<string, string>;
-    /** names whose values are secret, for `--secret-env-vars` and for masking */
-    secret: string[];
-    /** anything true but unwelcome: a location that will be slow, a stale default */
-    warnings: string[];
-}
-/**
- * Turns a zen key entry and a model id into copilot's environment.
- *
- * `COPILOT_PROVIDER_BASE_URL` is what activates BYOK at all, so every provider
- * gets one — including OpenAI, whose url copilot would otherwise have reached
- * through a GitHub account we are deliberately not using.
- */
-export declare function wire(store: KeyStore, entry: KeyEntry, id: string): Wiring;
-/** Values a `--dry-run` may print. A key is four characters and an apology. */
-export declare function masked(env: Record<string, string>, secret: readonly string[]): string[];
-/** `/project-review`, `project-review`, `project-review.prompt.md` or a path. */
-export declare function promptPath(dir: string, name: string): string;
-export interface StoredPrompt {
-    name: string;
-    path: string;
-    description?: string;
-    body: string;
-}
-/**
- * Frontmatter is the editor's business — `mode`, `tools`, `description` — and
- * none of it means anything to copilot, so only the body is sent. `description`
- * is kept for the one line of narration that says which prompt is running.
- */
-export declare function readPrompt(path: string, name: string, text: string): StoredPrompt;
-export declare function loadPrompt(dir: string, name: string): Promise<StoredPrompt>;
-export declare function listPrompts(dir: string): Promise<string[]>;
-export interface Binary {
-    command: string;
-    args: string[];
-    from: 'path' | 'npx';
-}
-/**
- * A `copilot` already installed is used as it is; otherwise `npx` fetches one.
- * Note that finding the name on `PATH` is not the same as finding the CLI —
- * an editor may have put a shim there that installs it on first run — so this
- * only decides how to launch, never whether it will work.
- */
-export declare function locate(has?: (cmd: string) => boolean): Binary;
-interface Event {
-    type: string;
-    data?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface Outcome {
-    /** the last thing the agent said that was not a preamble to a tool call */
-    answer: string;
-    exitCode: number;
-    sessionId?: string;
-    usage?: Record<string, unknown>;
-    events: Event[];
-}
-export interface Sink {
-    answer(text: string): void;
-    narrate(line: string): void;
-    warn(line: string): void;
-    /** Kept by the log, never shown: the step-by-step nobody reads while it runs. */
-    detail?(line: string): void;
-    /** A transient last row, replaced each time and never kept. '' removes it. */
-    status?(line: string): void;
-    /** Called once when the run ends, so a repainting sink can clear itself. */
-    close?(): void;
-}
-export declare const terminalSink: Sink;
-/** Rows of narration the window keeps on screen. */
-export declare const WINDOW_ROWS = 8;
-/** How often the border is redrawn — the wave's frame, not the clock's. */
-export declare const FRAME_MS = 80;
-/** Cells the crest travels per frame — a lap of a wide window in a few seconds. */
-export declare const WAVE_STEP = 3;
-/**
- * How brightly one cell of the border is lit, given where the crest has got to.
- *
- * `position` counts clockwise from the top left corner, so one index walks the
- * whole ring and the wave rounds the corners without a seam. Everything the
- * tail has passed sits at the dimmest tone, which is the border's resting
- * colour: the ring is always drawn, only the crest moves.
- */
-export declare function toneAt(position: number, head: number, span: number): number;
-/**
- * The bottom rule as cells, with the status label set into it near the left.
- *
- * Waiting belongs to the frame rather than to the narration: a row of its own
- * costs a step of what the agent is doing every time, and it settles just
- * under the last line, which is where the eye already is. Near the left, where
- * reading starts, and not so near that it displaces the corner.
- */
-export declare function footerCells(label: string, width: number): string[];
-/**
- * Narration held to a fixed number of rows that rewrite themselves in place.
- *
- * A long run is hundreds of tool calls, and printing each as its own line
- * scrolls the question, the model line and every warning off the top of the
- * screen — by the end the terminal holds a transcript nobody asked for and the
- * answer is somewhere in the middle of it. Only the last few steps say what it
- * is doing now, which is the only thing narration is for; the rest is in the
- * session copilot recorded.
- *
- * Warnings are not narration: they leave the window and stay on the screen.
- *
- * Without a terminal there is nothing to rewrite over, so every line is its
- * own — which is what a CI log wants anyway.
- */
-export declare function windowSink(rows?: number): Sink;
-/**
- * The answer in the same box `zen run` draws it in: bounded width, rounded
- * rule, formatted with full markdown styling (bold, italics, code, lists, quotes, tables).
- *
- * Redirected output gets the text and nothing else — `zen meta run ... > out.md`
- * is meant to produce a file you can read, not one with a border down its side.
- */
-export declare function answerBox(text: string, columns?: number): string[];
-export interface Log {
-    readonly path: string;
-    /** Where the answer alone goes, beside the log and openable on its own. */
-    readonly answerPath: string;
-    line(text: string): void;
-    saveAnswer(text: string): void;
-    close(): void;
-}
-/** `<project>/.tmp/logs/meta.<when>.log`, opened for append. */
-export declare function openLog(dir: string, now?: Date): Log;
-/**
- * Every meta session the project ran and how it ended, so `zen meta resume`
- * needs no id. `running` is never overwritten by a run that was killed, so it
- * reads the same as `failed`: not finished.
- */
-export type SessionState = 'running' | 'done' | 'failed';
-export declare function recordSession(dir: string, id: string, state: SessionState): void;
-/**
- * The newest session that did not finish, else the newest of all. A quick
- * question asked after a long run stopped must not stand in for it.
- */
-export declare function lastSession(dir: string): string | undefined;
-/**
- * Folds one event into the outcome and says what, if anything, to show for it.
- *
- * `assistant.message` carries both the running commentary and the final word;
- * what separates them is `toolRequests`, so the last message that asked for no
- * tool is the answer and the rest are narration.
- */
-export declare function absorb(event: Event, out: Outcome, sink: Sink, width: number): void;
-export interface Launch {
-    binary: Binary;
-    args: string[];
-    env: Record<string, string>;
-    cwd: string;
-    sink?: Sink;
-    log?: Log;
-    width?: number;
-    /** said after the elapsed time on the status row, e.g. the tokens so far */
-    status?: () => string;
-    /** injected by the tests, which have no copilot and want none */
-    spawn?: typeof nodeSpawn;
-}
-export declare function launch(opts: Launch): Promise<Outcome>;
-/** Resumes after copilot's own retries run out; `--retries` overrides. */
-export declare const DEFAULT_RESUMES = 5;
-/** What the resumed session is told, since `-p` has to say something. */
-export declare const RESUME_PROMPT = "The previous model call failed. Continue the task from where you stopped.";
-export declare function resumeDelayMs(attempt: number): number;
-/**
- * Why the run is worth resuming, or undefined when waiting cannot help.
- *
- * Only a refusal that time can cure counts: a rate limit, the provider's own
- * failure, a connection that timed out. A 400 or a bad key fails the same way
- * however often it is sent - except the one below.
- */
-export declare function transient(out: Outcome): string | undefined;
-export interface MetaCall {
-    model: string;
-    usage: TokenUsage;
-    cacheWriteTokens?: number;
-    startedAt: string;
-    durationMs: number;
-    session?: string;
-    traceId?: string;
-    spanId?: string;
-}
-/**
- * One line of the span file, as a model call - anything else is undefined.
- * Only counts are read off it: whatever else a span may carry, none of it
- * reaches the ledger.
- */
-export declare function readSpan(line: string): MetaCall | undefined;
-/** Whole lines out of a stream read in chunks; the unfinished tail is carried. */
-export declare function splitLines(carry: string, chunk: string): {
-    lines: string[];
-    carry: string;
-};
-/** Reads a span file as it grows. `stop()` reads what is left, once. */
-export declare function tailSpans(path: string, onCall: (call: MetaCall) => void, everyMs?: number): {
-    stop: () => void;
-};
-/** Calls and tokens so far, in the one line the status row and the summary share. */
-export declare class Tally {
-    calls: number;
-    usage: TokenUsage;
-    add(call: MetaCall): void;
-    toString(): string;
-}
-/** 950, 12.3k, 1.8M. */
-export declare function compact(n: number): string;
-/**
- * Copilot's own per-model totals from the last `session.shutdown` in a session's
- * events - cumulative over every resume of it. Reasoning folded into output,
- * as everywhere in zen.
- */
-export declare function shutdownModels(events: string): ModelUsage[] | undefined;
-export declare function sessionTotals(sessionId: string): ModelUsage[] | undefined;
-/** Non-fatal, said once, because a competing file is a silent override. */
-export declare function providersWarning(): string | undefined;
-export {};
-//# sourceMappingURL=meta.d.ts.map